Done? Done!

냈어? 냈어! · 업데이트 안내

코드 두 개만 바꾸면 5분 안에 끝나요

기존에 쓰시던 스프레드시트와 학생 코드는 그대로 유지됩니다. 아래 버튼으로 코드를 복사해서 Apps Script에 붙여넣기만 하면 됩니다.

Done? Done! v3.1.0 배포일 2026-09-04

이번 업데이트 (v3.1.0) — 파일 여러 개 첨부

학생 제출·과제 등록 모두 파일을 여러 개 붙일 수 있습니다 — 한 번에 여러 개를 고르거나 끌어다 놓으면 됩니다.
올린 파일은 목록에서 하나씩 지우거나 더 추가할 수 있습니다. 과제를 수정할 때도 기존 첨부는 그대로 두고 파일만 더할 수 있습니다.
첨부는 이미지·PDF 모두 차례로 미리보기됩니다. 스프레드시트는 손대지 않아도 되고, 지금까지 올린 첨부도 그대로 보입니다.

지난 버전에서 바뀐 것 모두 보기 (v3.0.1 · v3.0 · v2.2 · v2.1)

v3.0.1에서 고쳐진 것

선생님이 등록한 과제가 학생 화면에 하나도 안 뜨던 문제 — 반 이름이 "3-1"처럼 숫자와 붙임표로 되어 있으면 구글 시트가 이 값을 날짜(2026-03-01)로 바꿔서 저장해 버렸습니다. 그러면 과제의 '대상수업'과 학생의 '수업장소'가 서로 다른 값이 되어, 선생님 화면에는 과제가 멀쩡히 보이는데 학생 화면만 "등록된 과제가 없습니다"로 비어 있었습니다. 이제 대상수업을 글자 그대로 저장하고, 이미 날짜로 바뀌어 저장된 기존 과제도 업데이트 직후 자동으로 되돌립니다. (선생님이 따로 하실 일은 없습니다)
반 이름을 "3 - 1", "3/1"처럼 조금 다르게 적어 두어도 같은 반으로 알아봅니다 — 학생 명단과 과제의 반 표기가 어긋나 과제·제출 현황이 비어 보이던 문제도 함께 해결됩니다.
학생이 앱을 켜 둔 채로 있어도 [과제 제출] 탭을 다시 누르면 과제 목록을 새로 받아옵니다 — 수업 중에 과제를 올려도 학생이 새로고침할 필요가 없습니다.
학생 화면에 과제가 없을 때 지금 접속한 반 이름을 함께 표시합니다 — 반이 잘못 지정된 경우를 바로 알아볼 수 있습니다.
과제를 수정할 때도 대상수업·마감일이 날짜로 바뀌지 않도록 막았습니다.

v3.0에서 새로 생긴 것

학생 자동 로그인 — 학생이 로그인 화면에서 [이 기기에서 자동 로그인]을 체크해 두면, 다음부터는 앱을 열자마자 6자리 코드 없이 바로 자기 화면으로 들어갑니다. 코드는 그 기기에만 저장되고 서버에는 아무것도 남지 않습니다. 로그아웃을 누르면 저장이 지워지고, 선생님이 학생을 지우거나 코드가 바뀌면 저장된 코드도 자동으로 정리됩니다. 공용 기기에서는 체크하지 않도록 안내해 주세요. (워드클라우드 QR로 들어온 경우에는 자동 로그인이 동작하지 않아 QR 참여가 그대로 유지됩니다.)
참 잘했어요 도장 — 피드백을 쓸 때 도장을 1~3개까지 함께 찍어줄 수 있습니다. 학생 화면 맨 위에 지금까지 모은 도장이 바로 보입니다.
학급공약 — "도장 100개 모으면 영화 보기"처럼 반 전체 목표를 걸어두고, 모이면 [공약 실시]를 눌러 도장을 차감합니다.
학생 화면에 우리 반이 함께 모은 도장과 목표까지 남은 개수가 표시됩니다.
선생님 사이드바에 🏅 도장 · 학급공약 메뉴 추가 — 반 전체 도장 현황, 많이 받은 학생 1~3위, 공약 등록·실시를 한 화면에서.
학생 이름 수정 기능 추가 — 이름을 고치면 예전 제출물·피드백과 드라이브 폴더 이름까지 함께 정리됩니다. 6자리 코드는 그대로라 학생이 다시 로그인할 필요가 없습니다.
제출물을 반려하면 그 과제로 줬던 도장도 자동으로 회수됩니다.
클래스 이름을 바꾸거나 지울 때 그 반의 학급공약 기록도 함께 따라옵니다.
☁️ 워드클라우드 — 질문을 하나 던지면 학생들이 답한 단어가 화면에 실시간으로 모이고, 많이 나온 단어일수록 크게 보입니다. 전체화면으로 띄우면 그대로 수업 자료가 됩니다.
학생은 QR코드만 찍으면 참여합니다 — 6자리 코드도 로그인도 필요 없습니다. 1인당 제출 횟수(기본 5회)는 선생님이 정하시고, 자주 쓰는 질문은 프리셋으로 저장해 두고 다음 시간에 다시 부를 수 있습니다.

v2.2에서 고쳐진 것

선생님이 쓴 피드백이 학생에게 보이지 않던 문제 — "저장되었습니다"가 떴는데도 학생 화면에는 '피드백 대기'로 남던 현상입니다. 학생목록의 학번 칸이 비어 있는 반에서 특히 자주 났습니다.
같은 원인으로 다른 학생의 제출물이 엉뚱한 학생 카드에 보이던 문제
제출한 뒤에 학번을 채워 넣으면 그 학생의 제출물·피드백이 끊기던 문제
스프레드시트 메뉴에 [🩺 피드백 연결 점검] 추가 — 학생에게 안 보이는 피드백을 찾아줍니다
클래스 이름 변경·삭제 기능 추가
학생별·과제별 엑셀 내려받기(생활기록부 참고자료) 추가

v2.1에서 고쳐진 것

선생님이 쓴 과제 설명이 학생 화면에 나오지 않던 문제
화면의 버튼이 동작하지 않던 문제
제출 시각이 9시간 어긋나 보이던 문제
학생이 올린 파일이 엉뚱한 폴더에 저장되던 문제
과제를 지운 뒤 새로 만들면 남의 제출물이 딸려오던 문제
학생 일괄 등록이 너무 느리던 문제 (30명 기준 수십 초 → 수 초)
반려한 학생이 다시 제출해도 계속 '반려'로 보이던 문제
학생에게 다른 반 과제까지 보이던 문제
접근할 수 없던 현황판 메뉴 복구, 과제 첨부파일 제거 기능 추가

업데이트 방법

아래 순서를 그대로 따라가 주세요. 순서가 중요합니다 — 특히 3단계는 4단계(배포)보다 반드시 먼저입니다.

선택 · 권장

안전을 위해 시트 사본 만들기

평소 쓰시던 스프레드시트에서 [파일] → [사본 만들기] 를 눌러 백업을 하나 남겨두세요. 혹시 중간에 문제가 생겨도 이 사본으로 바로 되돌릴 수 있습니다.

가장 중요

코드 복사해서 붙여넣기

평소 쓰시던 스프레드시트 → [확장 프로그램] → [Apps Script] 를 여세요. 그다음 파일 두 개를 각각 이렇게 바꿉니다.

왼쪽 파일 목록에서 해당 파일을 클릭
편집창 아무 곳이나 클릭 → 전체 선택 (Ctrl+A, Mac은 Cmd+A)
아래 복사하기 버튼을 눌러 새 코드를 복사했다면 → 붙여넣기 (Ctrl+V)
저장 (Ctrl+S)

Code.gs

Apps Script 왼쪽 목록의 Code.gs 파일에 붙여넣으세요.

코드 미리보기

// =============================================
// ✅ 스프레드시트 연결
// ---------------------------------------------
//  ★ 여기는 비워두세요. 손댈 필요 없습니다.
//
//  연결할 시트는 아래 순서로 자동 결정됩니다:
//    ① 이 프로젝트에 저장된 설정값 (한 번 정하면 계속 유지)
//    ② 이 스크립트가 붙어 있는 스프레드시트 (확장 프로그램 → Apps Script로 만든 경우)
//    ③ 아래 상수 (예전 방식 — 이미 쓰던 분들의 호환용)
//
//  ①이 코드보다 우선하므로, 나중에 코드를 최신본으로 붙여넣어도
//  내 시트 연결이 풀리지 않습니다.
//  (예전에는 이 줄에 남의 시트 ID가 박힌 채 배포되면 그 시트를 건드리는
//   사고가 날 수 있었습니다)
const SPREADSHEET_ID = "";
// ✅ 파일이 저장될 구글 드라이브 폴더 ID
// Drive에서 폴더 만든 후 URL의 마지막 ID를 붙여넣으세요.
// 비워두면 내 드라이브 루트에 "DoneDone_Files" 폴더가 자동 생성됩니다.
const DRIVE_FOLDER_ID = "";
// =============================================

// 기본 비밀번호 (스프레드시트 설정 시트에서 덮어씁니다)
const DEFAULT_TEACHER_PASSWORD = "12345678";

// ── 연결된 스프레드시트 찾기 ───────────────────────
const PROP_SS_ID = "DD_SPREADSHEET_ID";

function getSpreadsheetId() {
  let props = null;
  try { props = PropertiesService.getScriptProperties(); } catch(e) {}

  // ① 이 스크립트가 붙어 있는 스프레드시트가 최우선.
  //    ★ 사본(파일 → 사본 만들기)으로 배포했을 때, 혹시 예전 설정값이
  //      함께 복사되더라도 원본 시트를 건드리는 사고를 막는다.
  //      "내가 붙어 있는 시트"보다 확실한 정답은 없다.
  try {
    const active = SpreadsheetApp.getActiveSpreadsheet();
    if (active) {
      const id = active.getId();
      if (props && props.getProperty(PROP_SS_ID) !== id) {
        try { props.setProperty(PROP_SS_ID, id); } catch(e) {}
      }
      return id;
    }
  } catch(e) {}

  // ② 이 프로젝트에 저장해 둔 값 (독립 프로젝트용 · 코드를 새로 붙여넣어도 유지)
  try {
    const saved = props ? props.getProperty(PROP_SS_ID) : null;
    if (saved) return saved;
  } catch(e) {}

  // ③ 예전 방식 (상단 상수)
  if (SPREADSHEET_ID) return SPREADSHEET_ID;

  throw new Error(
    "연결된 스프레드시트가 없습니다.\n\n" +
    "스프레드시트를 열고 [✏️ Done? Done!] 메뉴 → [① 최초 설정] 을 한 번 실행해 주세요.\n" +
    "(독립 프로젝트라면 Apps Script 편집기에서 bindSpreadsheet(\"시트ID\") 를 실행하세요)"
  );
}

// 연결된 스프레드시트 객체
function getSS() {
  return SpreadsheetApp.openById(getSpreadsheetId());
}

/**
 * 연결할 스프레드시트를 직접 지정한다 (독립 프로젝트용).
 * Apps Script 편집기에서 아래처럼 실행:
 *   function run() { bindSpreadsheet("여기에_시트ID"); }
 */
function bindSpreadsheet(id) {
  id = String(id || "").trim();
  // 전체 URL을 붙여넣어도 ID만 뽑아낸다
  const m = id.match(/\/d\/([a-zA-Z0-9-_]+)/);
  if (m) id = m[1];
  if (!id) throw new Error("시트 ID를 넣어주세요.");

  // 실제로 열리는지 먼저 확인
  const ss = SpreadsheetApp.openById(id);
  PropertiesService.getScriptProperties().setProperty(PROP_SS_ID, id);
  try { PropertiesService.getScriptProperties().deleteProperty(SETUP_FLAG); } catch(e) {}
  const msg = "✅ 연결되었습니다: " + ss.getName() + "\n(" + id + ")";
  Logger.log(msg);
  return msg;
}

/** 지금 어느 시트에 연결돼 있는지 확인 */
function whichSpreadsheet() {
  let msg;
  try {
    const ss = getSS();
    msg = "현재 연결된 시트\n\n• 이름: " + ss.getName() + "\n• ID: " + ss.getId() + "\n• 주소: " + ss.getUrl();
  } catch(e) {
    msg = "❌ " + e.message;
  }
  Logger.log(msg);
  try { SpreadsheetApp.getUi().alert("Done? Done! 연결 상태", msg, SpreadsheetApp.getUi().ButtonSet.OK); } catch(e) {}
  return msg;
}

// 스프레드시트 '설정' 시트에서 교사 비밀번호 읽기
function getTeacherPassword() {
  try {
    const ss = getSS();
    const sh = ss.getSheetByName("⚙️ 설정");
    if (!sh) return DEFAULT_TEACHER_PASSWORD;
    const data = sh.getDataRange().getValues();
    for (let i = 1; i < data.length; i++) {
      if (String(data[i][0]).trim() === "교사 비밀번호") {
        const pw = String(data[i][1]).trim();
        return pw || DEFAULT_TEACHER_PASSWORD;
      }
    }
  } catch(e) {}
  return DEFAULT_TEACHER_PASSWORD;
}

// 설정 시트에서 교사 성명 읽기
function getTeacherName() {
  try {
    const ss = getSS();
    const sh = ss.getSheetByName("⚙️ 설정");
    if (!sh) return "";
    const data = sh.getDataRange().getValues();
    for (let i = 1; i < data.length; i++) {
      if (String(data[i][0]).trim() === "교사 성명") {
        return String(data[i][1]).trim();
      }
    }
  } catch(e) {}
  return "";
}

// 설정 시트에서 디자인 테마 읽기
function getDesignTheme() {
  try {
    const ss = getSS();
    const sh = ss.getSheetByName("⚙️ 설정");
    if (!sh) return "기본";
    const data = sh.getDataRange().getValues();
    for (let i = 1; i < data.length; i++) {
      if (String(data[i][0]).trim() === "디자인 테마") {
        return String(data[i][1]).trim() || "기본";
      }
    }
  } catch(e) {}
  return "기본";
}

// 시트 이름 (한글)
const SHEET = {
  학생목록:  "학생목록",
  과제목록:  "과제목록",
  제출물:    "제출물",
  피드백:    "피드백",
  클래스목록: "클래스목록",
  학급공약:  "학급공약",
  사용설명서: "📖 사용설명서",
  설정:      "⚙️ 설정"
};

// ── 도장(참 잘했어요) ─────────────────────────────
// 도장은 피드백과 1:1로 붙는다. 그래서 별도 시트를 만들지 않고
// 피드백 시트의 G열(도장)에 함께 저장한다.
// 이렇게 하면 도장을 주고받는 데 시트 왕복이 한 번도 늘지 않는다.
//   · 저장: 피드백 행에 열 하나가 늘 뿐 (왕복 +0)
//   · 조회: getMySubmissions·getAllSubmissions가 이미 피드백 시트를 통째로
//           읽고 있으므로, 그 루프에서 더하기만 하면 된다 (왕복 +0)
const STAMP_COL = 7;       // 피드백 시트에서 도장이 들어가는 열
const STAMP_MAX = 3;       // 한 번에 줄 수 있는 최대 개수

// 시트에서 읽은 도장 값을 0~3 사이 정수로 정리한다
function parseStamp(v) {
  const n = parseInt(v, 10);
  if (isNaN(n) || n < 0) return 0;
  return n > STAMP_MAX ? STAMP_MAX : n;
}

// ── 시트 메뉴 (스프레드시트에서 열었을 때만 표시) ──
function onOpen() {
  try {
    const ui = SpreadsheetApp.getUi();
    ui.createMenu('✏️ Done? Done!')
      .addItem('① 최초 설정 / 시트 만들기', 'setupSpreadsheet')
      .addSeparator()
      .addItem('② 기존 데이터 이어쓰기 (업그레이드)', 'upgradeExisting')
      .addItem('③ 예전 시트에서 가져오기', 'showImportPrompt')
      .addSeparator()
      .addItem('🔎 연결된 시트 확인', 'whichSpreadsheet')
      .addItem('🩺 피드백 연결 점검', 'checkFeedbackLinks')
      .addItem('📖 사용설명서 새로 만들기', 'updateManualSheet')
      .addToUi();
  } catch(e) {}
}

/**
 * 🩺 피드백 연결 점검 (읽기 전용 — 시트를 고치지 않는다)
 *
 * 학생 화면에 붙을 곳이 없는 피드백(= 같은 과제에 그 학생의 제출물이 없는 행)을 찾아
 * 시트 행 번호와 함께 알려준다. 예전 버전에서 엉뚱한 학생 앞으로 저장돼
 * 아무에게도 보이지 않던 피드백이 있으면 여기서 드러난다.
 */
function checkFeedbackLinks() {
  const idx = buildStudentIndex();
  const fbSheet  = getSheet(SHEET.피드백);
  const subSheet = getSheet(SHEET.제출물);
  if (!fbSheet || !subSheet) {
    const m = "피드백 또는 제출물 시트를 찾을 수 없습니다.";
    Logger.log(m);
    try { SpreadsheetApp.getUi().alert(m); } catch(e) {}
    return m;
  }

  // 제출물에 실제로 존재하는 (과제ID_대표키) 목록
  const subKeys = {};
  const subData = subSheet.getDataRange().getValues();
  for (let i = 1; i < subData.length; i++) {
    if (!subData[i][0]) continue;
    subKeys[String(subData[i][2]) + "_" + canonKeyOf(idx, subData[i][0], subData[i][1])] = true;
  }

  const fbData = fbSheet.getDataRange().getValues();
  const orphans = [];
  for (let i = 1; i < fbData.length; i++) {
    if (!fbData[i][0]) continue;
    const key = String(fbData[i][0]) + "_" + canonKeyOf(idx, fbData[i][1], fbData[i][2]);
    if (subKeys[key]) continue;
    orphans.push(
      "· " + (i + 1) + "행 | 과제 " + String(fbData[i][0]) +
      " | 학번 " + String(fbData[i][1]) + " " + String(fbData[i][2] || "") +
      " | " + String(fbData[i][3] || "").slice(0, 30)
    );
  }

  let msg;
  if (!orphans.length) {
    msg = "✅ 모든 피드백이 제출물과 잘 이어져 있습니다. (총 " + (fbData.length - 1) + "건)";
  } else {
    msg = "⚠️ 학생에게 보이지 않는 피드백 " + orphans.length + "건을 찾았습니다.\n\n" +
          orphans.slice(0, 20).join("\n") +
          (orphans.length > 20 ? "\n… 외 " + (orphans.length - 20) + "건" : "") +
          "\n\n같은 과제에 그 학생의 제출물이 없어서 화면에 붙을 곳이 없는 기록입니다.\n" +
          "웹앱에서 해당 학생을 찾아 피드백을 다시 저장하시면 정상적으로 보입니다.";
  }
  Logger.log(msg);
  try { SpreadsheetApp.getUi().alert("피드백 연결 점검", msg, SpreadsheetApp.getUi().ButtonSet.OK); } catch(e) {}
  return msg;
}

// 예전 시트 ID를 입력받아 가져오기 실행
function showImportPrompt() {
  const ui = SpreadsheetApp.getUi();
  const res = ui.prompt(
    '예전 시트에서 데이터 가져오기',
    '예전에 쓰던 스프레드시트의 ID를 붙여넣어 주세요.\n\n' +
    '주소창 URL 중 /d/ 와 /edit 사이의 긴 문자열입니다.\n' +
    '예) docs.google.com/spreadsheets/d/[여기가 ID]/edit\n\n' +
    '· 학생들의 6자리 코드는 그대로 유지됩니다\n' +
    '· 여러 번 실행해도 중복 등록되지 않습니다',
    ui.ButtonSet.OK_CANCEL
  );
  if (res.getSelectedButton() !== ui.Button.OK) return;
  const id = res.getResponseText().trim();
  if (!id) { ui.alert('ID가 비어 있습니다.'); return; }
  try {
    importFromOldSpreadsheet(id);
  } catch(e) {
    ui.alert('가져오기 실패', String(e.message || e), ui.ButtonSet.OK);
  }
}

// ── 웹앱 진입점 ──────────────────────────────────
function apiHandler(params) {
  try {
    const e = { parameter: params };
    const out = handleRequest(e);
    return out.getContent();
  } catch(err) {
    return JSON.stringify({ success: false, message: err.toString() });
  }
}

function doGet(e) {
  const action = e && e.parameter && e.parameter.action;
  if (action) return handleRequest(e);

  const scriptUrl = ScriptApp.getService().getUrl();

  // ★ 학생 QR 접속 처리: ?wc=세션ID 파라미터 감지
  const wcParam = e && e.parameter && e.parameter.wc;
  if (wcParam) {
    const html = HtmlService.createHtmlOutputFromFile("index");
    const content = html.getContent()
      .replace(
        '</head>',
        '<meta name="wc-session-id" content="' + wcParam + '">\n<meta name="script-url" content="' + scriptUrl + '"></head>'
      );
    return HtmlService.createHtmlOutput(content)
      .addMetaTag('viewport', 'width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no')
      .setTitle("워드클라우드 참여")
      .setXFrameOptionsMode(HtmlService.XFrameOptionsMode.ALLOWALL);
  }

  const html = HtmlService.createHtmlOutputFromFile("index");
  const content = html.getContent()
    .replace(
      '</head>',
      '<meta name="script-url" content="' + scriptUrl + '"></head>'
    );

  return HtmlService.createHtmlOutput(content)
    .addMetaTag('viewport', 'width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no')
    .setTitle("Done? Done!")
    .setXFrameOptionsMode(HtmlService.XFrameOptionsMode.ALLOWALL);
}

function doPost(e) { return handleRequest(e); }

function handleRequest(e) {
  const params = e.parameter;
  const action = params.action;

  try {
    // ★ 시트 초기화는 필요할 때만.
    //   이전에는 요청마다 시트 8개를 확인해서, 워드클라우드 2초 폴링과 겹치면
    //   응답이 눈에 띄게 느려지고 실행 쿼터도 크게 소모했다.
    ensureSheetsOnce();

    let result;
    switch (action) {

      case "searchSubmissions":
        result = searchSubmissions(
          params.password,
          params.class_name   || "",
          params.student_name || "",
          params.assignment_id || ""
        );
        break;

      // ── 학생 ──────────────────────────────────
      case "login":
        result = loginStudent(params.code);
        break;

      case "getAssignments":
        result = getAssignments(params.class_target || "");
        break;

      case "getMySubmissions":
        result = getMySubmissions(params.student_code);
        break;

      case "submitAssignment":
        result = submitAssignment(
          params.student_code,
          params.assignment_id,
          params.content,
          params.file_url || "",
          params.student_name || ""
        );
        break;

      // ── 파일 업로드 ───────────────────────────
      case "uploadFile":
        result = uploadFileToDrive(
          params.fileName,
          params.mimeType,
          params.fileData,
          params.role || "student",
          params.student_name || ""
        );
        break;

      // ── 교사 ──────────────────────────────────
      case "teacherLogin":
        result = teacherLogin(params.password);
        break;

      case "getSettings":
        result = getSettings();
        break;

      case "getClasses":
        result = getClasses(params.password);
        break;

      case "addClass":
        result = addClassRoom(params.password, params.class_name);
        break;

      case "renameClass":
        result = renameClassRoom(params.password, params.class_id, params.new_name);
        break;

      case "deleteClass":
        result = deleteClassRoom(params.password, params.class_id);
        break;

      case "getAllSubmissions":
        result = getAllSubmissions(
          params.password,
          params.assignment_id || "",
          params.student_code  || ""
        );
        break;

      case "submitFeedback":
        result = submitFeedback(
          params.password,
          params.submission_id,
          params.student_code,
          params.assignment_id,
          params.content,
          params.stamps || 0
        );
        break;

      // -- 도장 / 학급공약 -----------------------
      case "getStampBoard":
        result = getStampBoard(params.password, params.class_name || "");
        break;

      case "addPledge":
        result = addPledge(
          params.password,
          params.class_name || "",
          params.content || "",
          params.goal || 0
        );
        break;

      case "deletePledge":
        result = deletePledge(params.password, params.pledge_id);
        break;

      case "executePledge":
        result = executePledge(params.password, params.pledge_id);
        break;

      case "rejectSubmission":
        result = rejectSubmission(
          params.password,
          params.submission_id,
          params.student_code,
          params.assignment_id
        );
        break;

      case "getAllFeedbacks":
        result = getAllFeedbacks(
          params.password,
          params.assignment_id || "",
          params.student_code  || ""
        );
        break;

      case "addAssignment":
        result = addAssignment(
          params.password,
          params.title,
          params.description,
          params.due_date     || "",
          params.class_target || "",
          params.file_url     || ""
        );
        break;

      case "updateAssignment":
        result = updateAssignment(
          params.password,
          params.assignment_id,
          params.title,
          params.description,
          params.due_date     || "",
          params.class_target || "",
          params.file_url     || "",
          params.keep_file    || ""
        );
        break;

      case "deleteAssignment":
        result = deleteAssignment(
          params.password,
          params.assignment_id
        );
        break;

      case "addStudent":
        result = addStudent(
          params.password,
          params.name,
          params.class_name,
          params.number || ""
        );
        break;

      case "bulkAddStudents":
        result = bulkAddStudents(
          params.password,
          params.students_json,
          params.class_name
        );
        break;

      case "getStudents":
        result = getStudents(params.password);
        break;

      case "renameStudent":
        result = renameStudent(
          params.password,
          params.code,
          params.new_name
        );
        break;

      // ── 워드클라우드 ──────────────────────────────
      case "wcCreateSession":
        result = wcCreateSession(
          params.password,
          params.question,
          params.maxPerPerson || "5"
        );
        break;

      case "wcGetSession":
        result = wcGetSession(params.sessionId);
        break;

      case "wcSubmitWord":
        result = wcSubmitWord(
          params.sessionId,
          params.word,
          params.studentId
        );
        break;

      case "wcGetResponses":
        result = wcGetResponses(params.sessionId);
        break;

      case "wcStopSession":
        result = wcStopSessionGas(params.password, params.sessionId);
        break;

      default:
        result = { success: false, message: "알 수 없는 요청입니다." };
    }

    return jsonResponse(result);

  } catch (err) {
    return jsonResponse({ success: false, message: err.toString() });
  }
}

// ── 공통 유틸 ────────────────────────────────────
function jsonResponse(data) {
  return ContentService
    .createTextOutput(JSON.stringify(data))
    .setMimeType(ContentService.MimeType.JSON);
}

function getSheet(name) {
  const ss = getSS();
  return ss.getSheetByName(name);
}

function generateId(prefix) {
  return prefix + "_" + new Date().getTime();
}

function generateCode() {
  const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
  let code = "";
  for (let i = 0; i < 6; i++) code += chars[Math.floor(Math.random() * chars.length)];
  return code;
}

// ── 과제ID 생성 (중복 불가) ────────────────────────
// 시간 기반이라 행 번호와 무관하다. 혹시라도 같은 밀리초에 두 번 만들어지면
// 뒤에 카운터를 붙여 회피한다.
function makeAssignmentId(sheet) {
  const existing = {};
  try {
    const data = sheet.getDataRange().getValues();
    for (let i = 1; i < data.length; i++) if (data[i][0]) existing[String(data[i][0])] = true;
  } catch(e) {}
  let id = "A" + new Date().getTime();
  let n = 0;
  while (existing[id]) { n++; id = "A" + new Date().getTime() + "_" + n; }
  return id;
}

// ── 학생 코드 목록 (중복 검사용) ───────────────────
// 학생목록 열: 수업장소(0) · 학번(1) · 이름(2) · 코드(3) · 등록일시(4)
// 이전에는 r[0](수업장소)을 코드로 착각해 읽어서 중복 검사가 전혀 동작하지 않았고,
// 서로 다른 학생에게 같은 코드가 발급될 수 있었다.
function collectExistingCodes(data) {
  const codes = [];
  for (let i = 1; i < data.length; i++) {
    const c = String(data[i][3] || "").trim().toUpperCase();
    if (c) codes.push(c);
  }
  return codes;
}

function now() {
  return Utilities.formatDate(new Date(), "Asia/Seoul", "yyyy-MM-dd HH:mm:ss");
}

// ── 시각 열을 텍스트 서식으로 고정 ─────────────────
// now()가 만든 "2026-08-09 14:30:00" 문자열을 그냥 appendRow 하면 구글 시트가
// 날짜값으로 자동 변환한다. 그러면 getValues()가 Date 객체를 돌려주고,
// JSON 직렬화 과정에서 UTC로 바뀌어 화면에 9시간 이르게 표시됐다.
// 해당 열을 텍스트(@)로 지정해 문자열 그대로 보관한다.
function forceTextColumn(sheet, col) {
  try {
    const maxRows = sheet.getMaxRows();
    if (maxRows >= 2) sheet.getRange(2, col, maxRows - 1, 1).setNumberFormat("@");
  } catch(e) {}
}

// 시트별로 시각이 들어가는 열을 텍스트로 맞춘다
function normalizeTimeColumns() {
  const ss = getSS();
  const targets = [
    [SHEET.제출물,   6],   // 제출일시
    [SHEET.피드백,   5],   // 작성일시
    [SHEET.학생목록, 5],   // 등록일시
    [SHEET.과제목록, 5],   // 등록일시
    [SHEET.과제목록, 4],   // 마감일
    [SHEET.클래스목록, 3]  // 등록일시
  ];
  targets.forEach(function(t) {
    const sh = ss.getSheetByName(t[0]);
    if (sh) forceTextColumn(sh, t[1]);
  });
  // 클래스별 시트도 함께 처리
  ss.getSheets().forEach(function(sh) {
    const n = sh.getName();
    if (n.endsWith(" 제출물")) forceTextColumn(sh, 6);
    else if (n.endsWith(" 피드백")) forceTextColumn(sh, 5);
  });
}

// 시트에서 읽은 값이 Date로 변환돼 있어도 한국시간 문자열로 되돌린다
// (이미 잘못 저장된 기존 데이터를 화면에서 바르게 보여주기 위함)
function asTimeText(v) {
  if (v instanceof Date) {
    return Utilities.formatDate(v, "Asia/Seoul", "yyyy-MM-dd HH:mm:ss");
  }
  return String(v == null ? "" : v);
}

// ── 클래스명(수업장소 · 대상수업) 표기 정리 ─────────
// "3-1" 같은 클래스명을 그냥 appendRow 하면 구글 시트가 날짜(2026-03-01)로
// 자동 변환한다. 학생목록·클래스목록·학급공약은 텍스트 서식을 지정해 막아 뒀지만
// 과제목록 F열(대상수업)만 빠져 있었다. 그래서 "3-1"반 대상으로 등록한 과제의
// 대상수업이 Date로 저장됐고, 학생의 수업장소("3-1")와 영원히 다른 값이 되어
// 교사는 등록했는데 학생 화면에는 과제가 하나도 안 보였다.
// 읽을 때는 항상 이 함수를 거쳐 사람이 입력한 표기로 되돌린다.
function classText(v) {
  if (v == null) return "";
  if (v instanceof Date) {
    // 날짜로 바뀐 값 → 원래 표기("3-1")로 복원
    return (v.getMonth() + 1) + "-" + v.getDate();
  }
  return String(v).trim();
}

// 비교 전용 키 — 공백을 없애고 구분자(. / _ – —)를 '-'로 통일한 뒤 대문자로 맞춘다.
// 교사가 학생과 과제에 같은 반을 다르게 적어 넣어도(예: "3 - 1", "3/1") 이어지게 한다.
function classKey(v) {
  return classText(v)
    .replace(/\s+/g, "")
    .replace(/[.\/_–—－]/g, "-")
    .toUpperCase();
}

function sameClass(a, b) {
  return classKey(a) === classKey(b);
}

// ── 클래스명이 날짜로 바뀌어 저장된 셀 복구 ─────────
// 이미 어긋난 채로 저장된 기존 데이터를 한 번 훑어 원래 표기로 되돌리고,
// 앞으로 다시 변환되지 않도록 해당 열을 텍스트 서식으로 고정한다.
function repairClassColumns() {
  const jobs = [
    [SHEET.학생목록, 1],   // 수업장소
    [SHEET.과제목록, 6],   // 대상수업
    [SHEET.클래스목록, 2], // 클래스명
    [SHEET.학급공약, 2]    // 클래스
  ];
  jobs.forEach(function (j) {
    try {
      const sh = getSheet(j[0]);
      if (!sh) return;
      forceTextColumn(sh, j[1]);          // 앞으로 들어올 값까지 텍스트로 고정
      if (sh.getLastRow() < 2) return;
      const range = sh.getRange(2, j[1], sh.getLastRow() - 1, 1);
      const vals  = range.getValues();
      let changed = 0;
      for (let i = 0; i < vals.length; i++) {
        if (vals[i][0] instanceof Date) { vals[i][0] = classText(vals[i][0]); changed++; }
      }
      if (changed) range.setValues(vals);
    } catch (e) {}
  });
}

// ── 학생 식별 공통 처리 ───────────────────────────
// 제출물·피드백 시트의 '학번' 열에는 학번이 있으면 학번이, 없으면 6자리 코드가 들어간다.
// 그래서 학번을 나중에 채워 넣거나 비워둔 반이 있으면 두 시트가 서로 다른 값을 갖게 되어
// 제출물과 피드백이 이어지지 않았다. 학생목록을 한 번 읽어 (학번·코드) 양쪽으로
// 찾을 수 있는 색인을 만들고, 조인은 항상 '대표키(canon)' 하나로만 한다.
// 학생목록 열: 수업장소(0), 학번(1), 이름(2), 코드(3), 등록일시(4)
function buildStudentIndex() {
  const idx = { byKey: {}, list: [] };
  const sh = getSheet(SHEET.학생목록);
  if (!sh) return idx;
  const data = sh.getDataRange().getValues();
  for (let i = 1; i < data.length; i++) {
    const num  = String(data[i][1] == null ? "" : data[i][1]).trim();
    const code = String(data[i][3] == null ? "" : data[i][3]).trim();
    if (!num && !code) continue;
    const stu = {
      class:  classText(data[i][0]),
      number: num,
      name:   String(data[i][2] || ""),
      code:   code,
      canon:  num || code.toUpperCase()   // 학번이 있으면 학번, 없으면 코드
    };
    idx.list.push(stu);
    if (code && !idx.byKey[code.toUpperCase()]) idx.byKey[code.toUpperCase()] = stu;
    if (num  && !idx.byKey[num])                idx.byKey[num]                = stu;
  }
  return idx;
}

// 6자리 코드(또는 학번)로 학생 찾기
function findStudentByCode(idx, code) {
  const k = String(code == null ? "" : code).trim();
  if (!k) return null;
  return idx.byKey[k.toUpperCase()] || idx.byKey[k] || null;
}

// 제출물·피드백 행의 '학번' 값 → 학생
// 학번을 중복으로 넣은 경우(반별 번호 1,2,3…)에는 같은 행의 이름으로 한 번 더 가린다.
function studentOfRow(idx, rawNum, rawName) {
  const k = String(rawNum == null ? "" : rawNum).trim();
  if (!k) return null;
  let stu = idx.byKey[k] || idx.byKey[k.toUpperCase()] || null;
  if (stu && rawName) {
    const same = idx.list.filter(function(s){ return s.number && s.number === k; });
    if (same.length > 1) {
      const byName = same.filter(function(s){ return String(s.name) === String(rawName); });
      if (byName.length === 1) stu = byName[0];
    }
  }
  return stu;
}

// 제출물·피드백 행을 이어붙일 때 쓰는 대표키
function canonKeyOf(idx, rawNum, rawName) {
  const stu = studentOfRow(idx, rawNum, rawName);
  if (stu) return stu.canon;
  return String(rawNum == null ? "" : rawNum).trim();
}

// 학생 한 명이 시트에 남길 수 있는 모든 표기(학번·코드)
function keySetOf(stu, fallback) {
  const set = {};
  if (stu) {
    if (stu.number) set[stu.number] = true;
    if (stu.code)   set[stu.code.toUpperCase()] = true;
  }
  const f = String(fallback == null ? "" : fallback).trim();
  if (f) { set[f] = true; set[f.toUpperCase()] = true; }
  return set;
}

function inKeySet(set, rawNum) {
  const k = String(rawNum == null ? "" : rawNum).trim();
  if (!k) return false;
  return !!(set[k] || set[k.toUpperCase()]);
}

// 한 학생을 다루는 데 필요한 것(학생목록 색인·본인 정보·표기 목록)을 한 번에 만든다.
// idx를 이미 만들어 뒀으면 넘겨서 재사용한다.
function whoOf(student_code, idx) {
  const index = idx || buildStudentIndex();
  const me = findStudentByCode(index, student_code);
  return {
    idx:   index,
    me:    me,
    keys:  keySetOf(me, student_code),
    canon: me ? me.canon : String(student_code == null ? "" : student_code).trim(),
    name:  me ? me.name  : "",
    cls:   me ? me.class : ""
  };
}

// 제출물·피드백 행이 이 학생의 것인가? (whoOf가 만든 값으로 판정)
function ownsRow(who, rawNum, rawName) {
  return isRowOf(who.idx, who.me, who.keys, rawNum, rawName);
}

// 제출물·피드백 행이 이 학생의 것인가?
// 반 번호(1,2,3…)를 학번 칸에 넣어 학번이 겹치는 경우에만 같은 행의 이름으로 한 번 더 가린다.
// (학번이 고유하거나 코드로 맞은 행이면 이름은 따지지 않는다 — 이름을 나중에 고친 경우를 위해)
function isRowOf(idx, me, keys, rawNum, rawName) {
  if (!inKeySet(keys, rawNum)) return false;
  if (!me || !me.name || !rawName) return true;
  const k = String(rawNum == null ? "" : rawNum).trim();
  if (!k || k !== me.number) return true;
  const dup = idx.list.filter(function(s){ return s.number && s.number === k; }).length > 1;
  if (!dup) return true;
  return String(rawName) === String(me.name);
}

// ── 시트 초기화를 한 번만 수행 ─────────────────────
// 스크립트 속성에 완료 표시를 남겨, 매 요청마다 시트를 훑지 않게 한다.
// 시트를 새로 만들거나 구조를 바꿨다면 setupSpreadsheet()를 실행하면 다시 검사한다.
// ★ V4 — 클래스명이 날짜로 바뀌어 저장된 셀(과제목록 '대상수업' 등)을 복구한다.
//   번호를 올려 두면 기존 사용자도 다음 요청 때 딱 한 번 구조 점검이 돌아간다.
const SETUP_FLAG = "DD_SHEETS_READY_V4";

function ensureSheetsOnce() {
  try {
    const props = PropertiesService.getScriptProperties();
    if (props.getProperty(SETUP_FLAG) === "1") return;
    initSheets();
    props.setProperty(SETUP_FLAG, "1");
  } catch(e) {
    // 속성 접근이 실패하면 안전하게 기존 동작(매번 초기화)으로 되돌린다
    initSheets();
  }
}

// ── 시트 자동 초기화 ──────────────────────────────
function initSheets() {
  const ss = getSS();

  // 학생목록
  if (!ss.getSheetByName(SHEET.학생목록)) {
    const sh = ss.insertSheet(SHEET.학생목록);
    sh.appendRow(["수업장소", "학번", "이름", "코드", "등록일시"]);
    styleHeader(sh);
  }

  // 과제목록
  if (!ss.getSheetByName(SHEET.과제목록)) {
    const sh = ss.insertSheet(SHEET.과제목록);
    sh.appendRow(["과제ID", "제목", "설명", "마감일", "등록일시", "대상수업", "파일URL", "파일명", "파일형식"]);
    styleHeader(sh);
  }

  // 제출물
  if (!ss.getSheetByName(SHEET.제출물)) {
    const sh = ss.insertSheet(SHEET.제출물);
    sh.appendRow(["학번", "이름", "과제ID", "내용", "파일URL", "제출일시", "파일명", "파일형식"]);
    styleHeader(sh);
  }

  // 피드백
  if (!ss.getSheetByName(SHEET.피드백)) {
    const sh = ss.insertSheet(SHEET.피드백);
    sh.appendRow(["과제ID", "학번", "이름", "내용", "작성일시", "반려여부", "도장"]);
    styleHeader(sh);
  }

  // 설정 시트
  if (!ss.getSheetByName(SHEET.설정)) {
    createSettingsSheet(ss);
  }

  // 클래스목록
  if (!ss.getSheetByName(SHEET.클래스목록)) {
    const sh = ss.insertSheet(SHEET.클래스목록);
    sh.appendRow(["클래스ID", "클래스명", "등록일시"]);
    styleHeader(sh);
    sh.setColumnWidth(1, 160);
    sh.setColumnWidth(2, 200);
    sh.setColumnWidth(3, 180);
  }

  // 학급공약
  initPledgeSheet();

  // 사용설명서
  if (!ss.getSheetByName(SHEET.사용설명서)) {
    createManualSheet(ss);
  }

  // 워드클라우드
  initWcSheet();

  // ★ 기존 사용자용 — 이미 만들어져 있던 피드백 시트들에 '도장' 열을 붙인다.
  //   SETUP_FLAG로 막혀 있어 딱 한 번만 돈다.
  ss.getSheets().forEach(function(sh) {
    const n = sh.getName();
    if (n === SHEET.피드백 || n.endsWith(" 피드백")) ensureStampColumn(sh);
  });

  // ★ 기존 사용자용 — 날짜로 바뀌어 저장된 클래스명("3-1" → 2026-03-01)을 되돌린다.
  //   이 값이 어긋나 있으면 교사가 등록한 과제가 학생 화면에 뜨지 않는다.
  repairClassColumns();
}

// ── 피드백 시트에 '도장' 열 보장 ───────────────────
// 이미 쓰던 시트라도 열 하나만 덧붙이면 되므로 기존 데이터는 그대로 남는다.
function ensureStampColumn(sheet) {
  if (!sheet) return;
  try {
    const maxCols = sheet.getMaxColumns();
    if (maxCols < STAMP_COL) sheet.insertColumnsAfter(maxCols, STAMP_COL - maxCols);
    if (String(sheet.getRange(1, STAMP_COL).getValue()).trim() === "도장") return;
    sheet.getRange(1, STAMP_COL)
      .setValue("도장")
      .setBackground("#4a86e8")
      .setFontColor("#ffffff")
      .setFontWeight("bold")
      .setFontSize(12);
    sheet.setColumnWidth(STAMP_COL, 80);
  } catch(e) { /* 열 추가 실패해도 나머지 기능은 그대로 동작한다 */ }
}

// ── 학급공약 시트 초기화 ───────────────────────────
// 도장 차감은 여기 '완료' 행으로만 일어난다. 반당 몇 행뿐이라 읽는 비용이 사실상 없다.
function initPledgeSheet() {
  const ss = getSS();
  if (ss.getSheetByName(SHEET.학급공약)) return;
  const sh = ss.insertSheet(SHEET.학급공약);
  sh.appendRow(["공약ID", "클래스", "공약내용", "목표도장", "상태", "생성일시", "실시일시"]);
  const hdr = sh.getRange(1, 1, 1, 7);
  hdr.setBackground("#e07a5f");
  hdr.setFontColor("#ffffff");
  hdr.setFontWeight("bold");
  hdr.setFontSize(12);
  sh.setFrozenRows(1);
  sh.setColumnWidth(1, 160);  // 공약ID
  sh.setColumnWidth(2, 140);  // 클래스
  sh.setColumnWidth(3, 420);  // 공약내용
  sh.setColumnWidth(4, 100);  // 목표도장
  sh.setColumnWidth(5, 100);  // 상태
  sh.setColumnWidth(6, 160);  // 생성일시
  sh.setColumnWidth(7, 160);  // 실시일시
  sh.getRange(1, 3, sh.getMaxRows(), 1).setWrap(true);
  forceTextColumn(sh, 6);
  forceTextColumn(sh, 7);
  // 클래스명("3-1" 등)이 날짜로 자동 변환되지 않게 텍스트로 고정
  forceTextColumn(sh, 2);
}

function styleHeader(sheet) {
  const headerRange = sheet.getRange(1, 1, 1, sheet.getLastColumn());
  headerRange.setBackground("#4a86e8");
  headerRange.setFontColor("#ffffff");
  headerRange.setFontWeight("bold");
  headerRange.setFontSize(12);
  sheet.setFrozenRows(1);

  const name = sheet.getName();

  // 시트별 열 너비 최적화
  if (name === "제출물") {
    sheet.setColumnWidth(1, 120);  // 학번
    sheet.setColumnWidth(2, 120);  // 이름
    sheet.setColumnWidth(3, 140);  // 과제ID
    sheet.setColumnWidth(4, 500);  // 내용 ← 크게
    sheet.setColumnWidth(5, 280);  // 파일URL
    sheet.setColumnWidth(6, 160);  // 제출일시
    sheet.setColumnWidth(7, 200);  // 파일명
    sheet.setColumnWidth(8, 120);  // 파일형식
    // 내용 칸 줄바꿈 허용
    sheet.getRange(1, 4, sheet.getMaxRows(), 1).setWrap(true);
  } else if (name === "피드백") {
    sheet.setColumnWidth(1, 140);  // 과제ID
    sheet.setColumnWidth(2, 120);  // 학번
    sheet.setColumnWidth(3, 120);  // 이름
    sheet.setColumnWidth(4, 500);  // 내용 ← 크게
    sheet.setColumnWidth(5, 160);  // 작성일시
    sheet.setColumnWidth(6, 100);  // 반려여부
    sheet.setColumnWidth(7, 80);   // 도장
    // 내용 칸 줄바꿈 허용
    sheet.getRange(1, 4, sheet.getMaxRows(), 1).setWrap(true);
  } else if (name === "학생목록") {
    sheet.setColumnWidth(1, 160);  // 수업장소
    sheet.setColumnWidth(2, 120);  // 학번
    sheet.setColumnWidth(3, 140);  // 이름
    sheet.setColumnWidth(4, 120);  // 코드
    sheet.setColumnWidth(5, 180);  // 등록일시
  } else if (name.endsWith(" 제출물")) {
    // 클래스별 제출물 시트
    sheet.setColumnWidth(1, 120);  // 학번
    sheet.setColumnWidth(2, 120);  // 이름
    sheet.setColumnWidth(3, 140);  // 과제ID
    sheet.setColumnWidth(4, 500);  // 내용
    sheet.setColumnWidth(5, 280);  // 파일URL
    sheet.setColumnWidth(6, 160);  // 제출일시
    sheet.setColumnWidth(7, 200);  // 파일명
    sheet.setColumnWidth(8, 120);  // 파일형식
    sheet.getRange(1, 4, sheet.getMaxRows(), 1).setWrap(true);
  } else if (name.endsWith(" 피드백")) {
    // 클래스별 피드백 시트
    sheet.setColumnWidth(1, 140);  // 과제ID
    sheet.setColumnWidth(2, 120);  // 학번
    sheet.setColumnWidth(3, 120);  // 이름
    sheet.setColumnWidth(4, 500);  // 내용
    sheet.setColumnWidth(5, 160);  // 작성일시
    sheet.setColumnWidth(6, 100);  // 반려여부
    sheet.setColumnWidth(7, 80);   // 도장
    sheet.getRange(1, 4, sheet.getMaxRows(), 1).setWrap(true);
  } else if (name === "과제목록") {
    sheet.setColumnWidth(1, 140);
    sheet.setColumnWidth(2, 200);
    sheet.setColumnWidth(3, 400);
    sheet.setColumnWidth(4, 120);
    sheet.setColumnWidth(5, 160);
    sheet.setColumnWidth(6, 160);
    sheet.setColumnWidth(7, 280);
    sheet.setColumnWidth(8, 200);
    sheet.setColumnWidth(9, 120);
    sheet.getRange(1, 3, sheet.getMaxRows(), 1).setWrap(true);
  } else {
    try { sheet.autoResizeColumns(1, sheet.getLastColumn()); } catch(e) {}
  }
}

// ── 설정 시트 생성 ────────────────────────────────
function createSettingsSheet(ss) {
  const sh = ss.insertSheet(SHEET.설정);

  // 헤더
  sh.appendRow(["설정 항목", "값", "설명"]);
  sh.appendRow(["교사 비밀번호", DEFAULT_TEACHER_PASSWORD, "교사 로그인 시 사용할 비밀번호 (영문·숫자 조합 권장)"]);
  sh.appendRow(["교사 성명", "", "로그인 화면에 표시될 교사 이름 (예: 홍길동)"]);
  sh.appendRow(["디자인 테마", "기본", "기본 / 봄 / 여름 / 가을 / 겨울 / 파스텔 / 파스텔-핑크 / 파스텔-민트 / 파스텔-스카이 / 파스텔-레몬 / 파스텔-라벤더 중 선택"]);

  // 헤더 스타일
  const hdr = sh.getRange(1, 1, 1, 3);
  hdr.setBackground("#1a73e8");
  hdr.setFontColor("#ffffff");
  hdr.setFontWeight("bold");
  hdr.setFontSize(12);

  // 비밀번호 행 스타일
  const pwRow = sh.getRange(2, 1, 1, 3);
  pwRow.setBackground("#fff8e1");
  sh.getRange(2, 1).setFontWeight("bold");
  sh.getRange(2, 2).setFontWeight("bold").setFontColor("#d32f2f");

  // 교사 성명 행 스타일
  sh.getRange(3, 1, 1, 3).setBackground("#e8f5e9");
  sh.getRange(3, 1).setFontWeight("bold");
  sh.getRange(3, 2).setFontWeight("bold").setFontColor("#2e7d32");

  // 디자인 테마 행 스타일 + 드롭다운 검증
  sh.getRange(4, 1, 1, 3).setBackground("#e8eaf6");
  sh.getRange(4, 1).setFontWeight("bold");
  const themeRule = SpreadsheetApp.newDataValidation()
    .requireValueInList(["기본","봄","여름","가을","겨울","파스텔","파스텔-핑크","파스텔-민트","파스텔-스카이","파스텔-레몬","파스텔-라벤더"], true)
    .setAllowInvalid(false).build();
  sh.getRange(4, 2).setDataValidation(themeRule).setFontWeight("bold").setFontColor("#283593");

  // 열 너비
  sh.setColumnWidth(1, 180);
  sh.setColumnWidth(2, 200);
  sh.setColumnWidth(3, 380);
  sh.setFrozenRows(1);

  // 안내 메모 추가
  sh.appendRow([]);
  sh.appendRow(["📌 안내", "", "이 시트에서 교사 비밀번호, 성명, 디자인 테마를 변경할 수 있습니다."]);
  sh.appendRow(["", "", "B열(값)만 수정하면 즉시 적용됩니다. 다른 셀은 수정하지 마세요."]);

  sh.getRange(6, 1).setFontWeight("bold").setFontColor("#1a73e8");
}

// ── 사용설명서 시트 생성 ──────────────────────────
function createManualSheet(ss) {
  const sh = ss.insertSheet(SHEET.사용설명서);

  const rows = [
    // 0: 제목
    ["📖 Done? Done! 사용설명서  (v2.0 · 2026)", "", ""],
    ["", "", ""],

    // 2: 최초 실행 안내 (★ 새로 추가)
    ["★ 처음 공유 받으셨나요? — 5분 안에 시작하기", "", ""],
    ["단계", "해야 할 일", "상세 설명"],
    ["1단계", "새 구글 스프레드시트 만들기", "drive.google.com → 새로 만들기 → Google 스프레드시트"],
    ["2단계", "Apps Script 열기", "시트 상단 [확장 프로그램] → [Apps Script]"],
    ["3단계", "코드 붙여넣기", "Code.gs 와 index.html 내용을 각각 붙여넣고 저장 (시트 ID는 입력할 필요 없음)"],
    ["4단계", "시트로 돌아와 새로고침 → [① 최초 설정] 실행", "상단 [✏️ Done? Done!] 메뉴 → [① 최초 설정] — 이 시트에 자동 연결됩니다"],
    ["5단계", "웹앱 배포하기", "배포 → 새 배포 → 유형: 웹앱 → 액세스: 모든 사용자 → 배포"],
    ["6단계", "배포된 URL을 학생·교사에게 공유!", "교사 초기 비밀번호: 12345678 (⚙️ 설정 시트에서 변경 가능)"],
    ["", "", ""],

    // 11: 시스템 소개
    ["■ 시스템 소개", "", ""],
    ["Done? Done!은 수업 과제 제출 및 관리 시스템입니다.", "", ""],
    ["교사는 과제를 등록하고 학생 제출물에 피드백을 제공할 수 있으며,", "", ""],
    ["학생은 고유 코드로 접속하여 과제를 제출하고 피드백을 확인합니다.", "", ""],
    ["", "", ""],

    // 16: 장점
    ["■ 이 시스템의 장점", "", ""],
    ["항목", "내용", ""],
    ["✅ 별도 설치 불필요", "웹 브라우저만 있으면 어디서든 접속 가능 (스마트폰·태블릿·PC)", ""],
    ["✅ 완전 무료", "구글 계정만 있으면 구글 Apps Script + 스프레드시트로 무료 운영", ""],
    ["✅ 파일 첨부 지원", "이미지·PDF를 Google Drive에 자동 저장, 학생별 폴더 자동 생성", ""],
    ["✅ 실시간 피드백", "교사가 작성한 피드백을 학생이 즉시 웹앱에서 확인 가능", ""],
    ["✅ 반려·재제출 기능", "부적절한 제출은 반려 처리 → 학생이 수정하여 재제출", ""],
    ["✅ 참 잘했어요 도장", "피드백과 함께 도장 1~3개 부여 → 학생별·학급별 누계 자동 집계", "★ v3.0 신규"],
    ["✅ 학급공약 이벤트", "목표 도장 수를 정해 두고, 달성하면 교사가 실시 → 학급 도장에서 차감", "★ v3.0 신규"],
    ["✅ 반별·학생별 검색", "교사 화면에서 수업장소/과제/학생별로 제출물 즉시 필터링", ""],
    ["✅ 스프레드시트 연동", "모든 데이터가 구글 시트에 실시간 기록 → 엑셀처럼 관리 가능", ""],
    ["✅ 개인정보 최소화", "학생은 이름·학번이 아닌 6자리 코드로만 접속 (익명성 보호)", ""],
    ["", "", ""],

    // 28: 스프레드시트 구성
    ["■ 스프레드시트 시트 구성", "", ""],
    ["시트명", "역할", "비고"],
    ["학생목록", "등록된 학생 정보 (코드·이름·수업장소·학번)", ""],
    ["과제목록", "교사가 등록한 과제 목록", ""],
    ["제출물", "학생이 제출한 과제 내용 및 파일 링크", ""],
    ["피드백", "교사의 피드백 및 반려 기록 (G열 = 참 잘했어요 도장 개수)", "★ v3.0 도장 열 추가"],
    ["학급공약", "반별 공약 내용·목표 도장 수·실시 기록 (도장 차감 내역)", "★ v3.0 신규"],
    ["클래스목록", "교사가 개설한 클래스 목록 (클래스ID·클래스명·등록일시)", "★ v2.0 신규"],
    ["⚙️ 설정", "교사 비밀번호 / 교사 성명 / 디자인 테마 변경", "★ v2.0 업데이트"],
    ["📖 사용설명서", "이 시트", ""],
    ["", "", ""],

    // ⚙️ 설정 시트 안내 (신규)
    ["■ ⚙️ 설정 시트 항목 안내", "", ""],
    ["설정 항목", "설명", "입력 예시"],
    ["교사 비밀번호", "교사 로그인 시 사용. B열 값만 수정하면 즉시 적용.", "abcd1234"],
    ["교사 성명", "로그인 화면에 '○○○ 선생님'으로 표시됨. 비워두면 표시 안 됨.", "홍길동"],
    ["디자인 테마", "화면 색상 테마. 아래 선택지 중 하나를 B열에 입력.", "봄"],
    ["  └ 선택 가능 테마", "기본 / 봄 / 여름 / 가을 / 겨울 / 파스텔 / 파스텔-핑크 / 파스텔-민트 / 파스텔-스카이 / 파스텔-레몬 / 파스텔-라벤더", ""],
    ["", "", ""],

    // 교사 사용법 v2.0
    ["■ 교사 사용 방법 (v2.0 — 클래스 기반)", "", ""],
    ["1단계", "웹앱 접속 → 교사 비밀번호 입력 → 교사로 접속", ""],
    ["2단계", "왼쪽 사이드바 '내 클래스' → [＋ 클래스 추가]로 클래스 개설", "예: 3-1, 3-2, 방과후A 등"],
    ["3단계", "클래스 이름 클릭 → 해당 클래스로 입장 (메뉴 4개 활성화)", ""],
    ["4단계", "[학생 관리] → 드롭다운에서 클래스 선택 후 학생 추가 → 코드 전달", ""],
    ["5단계", "[과제 관리] → 과제 등록 (수업장소에서 대상 클래스 선택 가능)", "비워두면 전체 공개"],
    ["6단계", "[학생별 보기] / [과제별 보기] → 제출 현황 확인 및 피드백 작성", ""],
    ["ℹ️ 클래스 나가기", "사이드바 배너의 '← 나가기' 클릭으로 클래스 나감", ""],
    ["", "", ""],

    // 학생 사용법
    ["■ 학생 사용 방법", "", ""],
    ["1단계", "웹앱 접속 → 선생님께 받은 6자리 코드 입력 → 학생으로 접속", ""],
    ["2단계", "[과제 제출] 탭에서 제출할 과제 카드 선택", ""],
    ["3단계", "활동 내용 작성 및 파일(이미지/PDF) 첨부 후 [제출하기] 클릭", ""],
    ["⚠️ 제출 주의", "제출 버튼 클릭 시 '제출 후에는 수정이 불가합니다' 확인창이 표시됨", "확인 후 제출됨"],
    ["4단계", "[내 제출물·피드백] 탭에서 피드백 확인 및 반려 시 재제출", ""],
    ["", "", ""],

    // 49: 파일 저장
    ["■ 파일 저장 위치 (Google Drive)", "", ""],
    ["학생 제출 파일", "DoneDone_Files > 제출물_학생 > [학생이름] 폴더에 자동 저장", ""],
    ["교사 과제 파일", "DoneDone_Files > 과제자료_교사 폴더에 자동 저장", ""],
    ["", "", ""],

    // 주의사항
    ["■ 주의사항", "", ""],
    ["·", "한 번 제출한 과제는 교사가 반려하기 전까지 수정 불가", ""],
    ["·", "반려된 과제는 내용을 수정하여 재제출 가능", ""],
    ["·", "파일 업로드 최대 용량: 50MB (이미지, PDF만 가능)", ""],
    ["·", "이 스프레드시트를 직접 수정하면 오류가 발생할 수 있습니다", ""],
    ["·", "비밀번호 변경은 반드시 [⚙️ 설정] 시트 B2 셀에서만 진행하세요", ""],
    ["·", "클래스목록 시트는 직접 편집하지 마세요. 웹앱에서 관리하세요.", ""],
    ["", "", ""],

    // 🆕 v2.0 업데이트 내역 (신규)
    ["🆕 v2.0 업데이트 내역 (2026-04)", "", ""],
    ["항목", "변경 내용", "구분"],
    ["클래스 관리 시스템", "클래스목록 시트 신규. 교사가 클래스를 개설하고 입장하여 관리.", "신규"],
    ["사이드바 클래스 메뉴", "클래스 미입장 시 메뉴 숨김 → 입장 후 4개 메뉴(학생별/과제별/과제관리/학생관리) 활성화", "신규"],
    ["교사 성명 표시", "설정 시트 '교사 성명' 항목 추가. 로그인 화면과 사이드바에 선생님 이름 표시.", "신규"],
    ["디자인 테마 선택", "설정 시트에서 봄·여름·가을·겨울·파스텔 테마 선택 가능 (드롭다운 적용)", "신규"],
    ["클래스 순서 유지", "클래스 목록이 최초 등록 순서대로 사이드바에 나열됨", "개선"],
    ["학생 추가 클래스 선택", "학생 추가 시 텍스트 입력 → 등록된 클래스 드롭다운 선택으로 개선. 현재 입장 클래스 자동 선택.", "개선"],
    ["제출 확인 경고창", "학생이 제출 버튼 클릭 시 '제출 후에는 수정이 불가합니다' 확인창 표시", "개선"],
    ["교사 이름 사이드바", "교사 로그인 후 사이드바에 👨‍🏫 ○○○ 선생님 형태로 이름 표시", "개선"],
    ["브랜드명 통일", "모든 화면에서 'Done? Done!' 영문 + '냈어? 냈어!' 한글 부제 통일", "개선"],
    ["", "", ""],

    // 저작권
    ["■ 저작권 및 이용 안내", "", ""],
    ["", "", ""],
    ["ⓒ 2026  황성재 (성포고등학교)  All Rights Reserved.", "", ""],
    ["", "", ""],
    ["본 웹앱(Done? Done!)의 소스코드, 디자인, 구조 및 사용설명서는", "", ""],
    ["저작권법의 보호를 받습니다.", "", ""],
    ["원저작자의 서면 동의 없이 무단 복제·배포·상업적 이용·2차 수정을 금합니다.", "", ""],
    ["교육 목적의 비상업적 공유는 원저작자 표기를 유지하는 조건으로 허용됩니다.", "", ""],
    ["", "", ""],
    ["🏫 제작자  :  황성재 선생님, 성포고등학교", "", ""],
    ["📷 인스타  :  @hirame.ki (instagram.com/hirame.ki)", "", ""],
    ["", "", ""],
    ["[ Done? Done! — 냈어? 냈어!  과제 제출이 이렇게 쉬워도 되나? 😄 ]", "", ""],
  ];

  rows.forEach((row, i) => {
    sh.appendRow(row);
    const r = sh.getRange(i + 1, 1, 1, 3);

    if (i === 0) {
      // 메인 제목
      r.setFontSize(18); r.setFontWeight("bold");
      r.setBackground("#1a73e8"); r.setFontColor("#ffffff");
    } else if (row[0] && row[0].startsWith("★")) {
      // 처음 실행 섹션 헤더
      r.setBackground("#e8f5e9"); r.setFontWeight("bold"); r.setFontSize(13);
      r.setFontColor("#2e7d32");
    } else if (row[0] && row[0].startsWith("🆕")) {
      // v2.0 업데이트 내역 헤더
      r.setBackground("#fff3e0"); r.setFontWeight("bold"); r.setFontSize(13);
      r.setFontColor("#e65100");
    } else if (i === 3 || i === 17 || i === 30 || i === 39 || i === 48 || i === 57 || i === 68) {
      // 표 헤더 행
      r.setBackground("#4a86e8"); r.setFontColor("#ffffff"); r.setFontWeight("bold");
    } else if (row[0] && row[0].startsWith("■")) {
      r.setBackground("#e8f0fe"); r.setFontWeight("bold");
    } else if (row[2] === "신규") {
      r.setBackground("#e8f5e9");
    } else if (row[2] === "개선") {
      r.setBackground("#f3e5f5");
    } else if (row[0] && row[0].startsWith("⚠️")) {
      r.setBackground("#fff8e1"); r.setFontColor("#f57f17"); r.setFontWeight("bold");
    } else if (row[0] && row[0].startsWith("ℹ️")) {
      r.setBackground("#e3f2fd"); r.setFontColor("#1565c0"); r.setFontWeight("bold");
    } else if (row[0] && row[0].startsWith("ⓒ")) {
      // 저작권 주요 행
      r.setFontWeight("bold"); r.setFontSize(12); r.setFontColor("#c62828");
    } else if (row[0] && row[0].startsWith("[ Done?")) {
      // Done? Done! 유머 행
      r.setBackground("#fff9c4"); r.setFontWeight("bold"); r.setFontColor("#f57f17");
    } else if (row[0] && (row[0].startsWith("🏫") || row[0].startsWith("📷"))) {
      r.setFontWeight("bold");
    }
  });

  sh.setColumnWidth(1, 230);
  sh.setColumnWidth(2, 520);
  sh.setColumnWidth(3, 130);
  sh.setFrozenRows(1);
  sh.setRowHeight(1, 40);
}

// ── 학생 폴더 가져오기 또는 생성 ──────────────────
function getStudentFolder(studentName) {
  let rootFolder;
  if (DRIVE_FOLDER_ID) {
    rootFolder = DriveApp.getFolderById(DRIVE_FOLDER_ID);
  } else {
    const folders = DriveApp.getFoldersByName("DoneDone_Files");
    rootFolder = folders.hasNext() ? folders.next() : DriveApp.createFolder("DoneDone_Files");
  }

  // 제출물_학생 폴더
  const subName = "제출물_학생";
  const subs = rootFolder.getFoldersByName(subName);
  const studentRoot = subs.hasNext() ? subs.next() : rootFolder.createFolder(subName);

  // 학생 이름 폴더
  if (studentName) {
    const studentFolders = studentRoot.getFoldersByName(studentName);
    return studentFolders.hasNext() ? studentFolders.next() : studentRoot.createFolder(studentName);
  }
  return studentRoot;
}

// ── 파일 업로드 → Drive 저장 ─────────────────────
function uploadFileToDrive(fileName, mimeType, base64Data, role, studentName) {
  if (!fileName || !mimeType || !base64Data)
    return { success: false, message: "파일 정보가 올바르지 않습니다." };

  try {
    const bytes = Utilities.base64Decode(base64Data);
    const blob  = Utilities.newBlob(bytes, mimeType, fileName);

    let folder;
    if (role === "teacher") {
      // 교사 파일: 과제자료_교사 폴더
      let rootFolder;
      if (DRIVE_FOLDER_ID) {
        rootFolder = DriveApp.getFolderById(DRIVE_FOLDER_ID);
      } else {
        const folders = DriveApp.getFoldersByName("DoneDone_Files");
        rootFolder = folders.hasNext() ? folders.next() : DriveApp.createFolder("DoneDone_Files");
      }
      const subName = "과제자료_교사";
      const subs = rootFolder.getFoldersByName(subName);
      folder = subs.hasNext() ? subs.next() : rootFolder.createFolder(subName);
    } else {
      // 학생 파일: 제출물_학생 > [학생이름] 폴더
      folder = getStudentFolder(studentName);
    }

    const file = folder.createFile(blob);
    file.setSharing(DriveApp.Access.ANYONE_WITH_LINK, DriveApp.Permission.VIEW);

    const fileId   = file.getId();
    const viewUrl  = "https://drive.google.com/file/d/" + fileId + "/view";
    const embedUrl = buildEmbedUrl(fileId, mimeType);

    return { success: true, fileId, viewUrl, embedUrl, fileName, mimeType };

  } catch (err) {
    return { success: false, message: "파일 저장 실패: " + err.toString() };
  }
}

function buildEmbedUrl(fileId, mimeType) {
  if (mimeType && mimeType.startsWith("image/")) {
    return "https://lh3.googleusercontent.com/d/" + fileId;
  }
  if (mimeType === "application/pdf") {
    return "https://drive.google.com/file/d/" + fileId + "/preview";
  }
  return "";
}

// ── 학생 로그인 ──────────────────────────────────
function loginStudent(code) {
  if (!code) return { success: false, message: "코드를 입력해주세요." };
  const sheet = getSheet(SHEET.학생목록);
  if (!sheet) return { success: false, message: "시스템 초기화 중입니다. 잠시 후 다시 시도해주세요." };
  const data = sheet.getDataRange().getValues();
  for (let i = 1; i < data.length; i++) {
    // 열 순서: 수업장소(0), 학번(1), 이름(2), 코드(3), 등록일시(4)
    if (String(data[i][3]).toUpperCase() === code.toUpperCase()) {
      return {
        success: true,
        student: {
          code:   data[i][3],
          name:   data[i][2],
          // ★ 날짜로 바뀌어 저장된 수업장소도 원래 표기로 되돌려 보낸다.
          //   (이 값이 그대로 과제 목록 조회의 대상수업 필터로 쓰인다)
          class:  classText(data[i][0]),
          number: data[i][1]
        }
      };
    }
  }
  return { success: false, message: "코드를 확인해주세요." };
}

// ── 과제 목록 조회 ───────────────────────────────
// 과제목록 시트 열: A=과제ID, B=제목, C=설명, D=마감일, E=등록일시, F=대상수업, G=파일URL, H=파일명, I=파일형식
function getAssignments(class_target) {
  const sheet = getSheet(SHEET.과제목록);
  if (!sheet) return { success: true, assignments: [] };
  const data = sheet.getDataRange().getValues();
  const assignments = [];
  // ★ 반 비교는 표기 차이(공백·구분자·날짜 변환)를 흡수한 뒤에 한다.
  //   예전에는 문자열을 그대로 비교해서, 시트가 "3-1"을 날짜로 바꿔 저장하거나
  //   교사가 "3 - 1"처럼 띄어 적으면 그 반 학생에게 과제가 하나도 안 보였다.
  const wanted = classKey(class_target);
  for (let i = 1; i < data.length; i++) {
    if (!data[i][0]) continue;
    const target = classText(data[i][5]);
    if (wanted && target && classKey(target) !== wanted) continue;
    assignments.push({
      // ★ 과제ID는 항상 문자열로 돌려준다.
      //   제출물·피드백 쪽은 문자열로 비교하는데 여기만 시트 원본(숫자일 수 있음)이라
      //   예전 숫자형 ID를 쓰던 시트에서 과제와 제출물이 이어지지 않았다.
      id:           String(data[i][0]),
      title:        data[i][1],
      description:  data[i][2],
      due_date:     asTimeText(data[i][3]).slice(0,10),
      created_at:   asTimeText(data[i][4]),
      class_target: target,
      file_url:     data[i][6] || "",
      file_name:    data[i][7] || "",
      mime_type:    data[i][8] || ""
    });
  }
  return { success: true, assignments };
}

// ── 내 제출물 조회 ───────────────────────────────
function getMySubmissions(student_code) {
  if (!student_code) return { success: false, message: "코드가 필요합니다." };

  // ★ 내 행을 찾을 때 학번·코드 두 표기를 모두 인정한다.
  //   (학번을 나중에 채워 넣으면 제출물은 코드로, 피드백은 학번으로 저장돼
  //    서로 이어지지 않아 "피드백을 저장했는데 학생에게 안 보이는" 문제가 났다)
  // 색인을 한 번만 만들어 아래 도장 집계와 함께 쓴다 (시트 왕복 절약)
  const idx = buildStudentIndex();
  const who = whoOf(student_code, idx);

  const subSheet = getSheet(SHEET.제출물);
  const fbSheet  = getSheet(SHEET.피드백);
  if (!subSheet) return { success: true, submissions: [] };

  const subData = subSheet.getDataRange().getValues();
  const fbData  = fbSheet ? fbSheet.getDataRange().getValues() : [[]];

  // 피드백맵: 과제ID → 최신 피드백 (이미 내 행만 걸러낸 뒤라 과제ID만으로 충분)
  // 피드백 시트: 과제ID(0), 학번(1), 이름(2), 내용(3), 작성일시(4), 반려여부(5), 도장(6)
  const feedbackMap = {};
  for (let i = 1; i < fbData.length; i++) {
    if (!fbData[i][0]) continue;
    if (!ownsRow(who, fbData[i][1], fbData[i][2])) continue;
    const key = String(fbData[i][0]);
    if (!feedbackMap[key] || asTimeText(fbData[i][4]) > feedbackMap[key].created_at) {
      feedbackMap[key] = {
        content:     fbData[i][3],
        created_at:  asTimeText(fbData[i][4]),
        is_rejected: String(fbData[i][5]) === "반려",
        stamps:      parseStamp(fbData[i][6])
      };
    }
  }

  // ★ 도장 집계 — 이미 읽어 둔 피드백 데이터로 계산하므로 시트 왕복이 늘지 않는다.
  const board = summarizeStamps(idx, fbData, who.cls, who);

  // 제출물 시트: 학번(0), 이름(1), 과제ID(2), 내용(3), 파일URL(4), 제출일시(5), 파일명(6), 파일형식(7)
  const submissions = [];
  for (let i = 1; i < subData.length; i++) {
    if (!ownsRow(who, subData[i][0], subData[i][1])) continue;
    const key = String(subData[i][2]);
    submissions.push({
      assignment_id: String(subData[i][2]),
      content:       subData[i][3],
      file_url:      subData[i][4] || "",
      file_name:     subData[i][6] || "",
      mime_type:     subData[i][7] || "",
      submitted_at:  asTimeText(subData[i][5]),
      feedback:      feedbackMap[key] || null
    });
  }
  return {
    success:     true,
    submissions: submissions,
    my_stamps:   board.my_stamps,       // 내 도장 총 누계
    stamp_board: {                      // 우리 반 현황
      class_name: who.cls,
      earned:     board.earned,         // 반 전체가 지금까지 모은 도장
      redeemed:   board.redeemed,       // 공약 실시로 쓴 도장
      available:  board.available,      // 남아 있는 도장
      pledges:    board.pledges
    }
  };
}

// ── 과제 제출 ────────────────────────────────────
// 제출물 시트 열: A=학번, B=이름, C=과제ID, D=내용, E=파일URL, F=제출일시, G=파일명, H=파일형식
// ★ 첨부 파일 문자열 분해 (복수 첨부 지원)
//   전달 형식: "URL|||파일명|||형식###URL|||파일명|||형식..."
//   저장 형식: URL열/파일명열/형식열에 각각 '###'로 이어 붙인다.
//   파일이 하나면 결과가 예전과 똑같아서 기존 데이터와 호환된다.
function splitFileParam(file_url) {
  const urls = [], names = [], mimes = [];
  String(file_url || "").split("###").forEach(function(chunk) {
    if (!chunk) return;
    const parts = chunk.split("|||");
    if (!parts[0]) return;
    urls.push(parts[0]);
    names.push(parts[1] || "");
    mimes.push(parts[2] || "");
  });
  return { urls: urls.join("###"), names: names.join("###"), mimes: mimes.join("###") };
}

function submitAssignment(student_code, assignment_id, content, file_url, student_name) {
  // content 또는 file_url 중 하나는 반드시 있어야 제출 가능
  const hasContent  = content && String(content).trim() !== "";
  const hasFile     = file_url && String(file_url).trim() !== "";
  if (!student_code || !assignment_id || (!hasContent && !hasFile))
    return { success: false, message: "필수 항목이 빠졌습니다." };

  // content가 없을 때 파일만 첨부된 경우 빈 문자열로 저장
  if (!hasContent) content = "";

  // 학생 정보 조회 (학번, 이름) — 학번이 비어 있으면 6자리 코드를 키로 쓴다
  const who = whoOf(student_code);
  const studentNumber = who.canon;
  const studentNameResolved = who.name || student_name || "";

  const subSheet = getSheet(SHEET.제출물);
  const fbSheet  = getSheet(SHEET.피드백);
  if (!subSheet) return { success: false, message: "시트 초기화 오류입니다." };

  const subData  = subSheet.getDataRange().getValues();
  const fbData   = fbSheet ? fbSheet.getDataRange().getValues() : [[]];

  // 반려 여부: 내 행(학번·코드 어느 표기든) 중 이 과제의 최신 기록
  // 피드백 시트: 과제ID(0), 학번(1), 이름(2), 내용(3), 작성일시(4), 반려여부(5)
  let isRejectedNow = false;
  let rejectedAt = "";
  for (let i = 1; i < fbData.length; i++) {
    if (!fbData[i][0]) continue;
    if (String(fbData[i][0]) !== String(assignment_id)) continue;
    if (!ownsRow(who, fbData[i][1], fbData[i][2])) continue;
    const t = asTimeText(fbData[i][4]);
    if (t >= rejectedAt) { rejectedAt = t; isRejectedNow = String(fbData[i][5]) === "반려"; }
  }

  // 중복 제출 체크: 학번(0) + 과제ID(2) 기준
  for (let i = 1; i < subData.length; i++) {
    if (ownsRow(who, subData[i][0], subData[i][1]) &&
        String(subData[i][2]) === String(assignment_id)) {
      if (isRejectedNow) break;
      return { success: false, message: "이미 제출한 과제입니다." };
    }
  }

  const packed = splitFileParam(file_url);
  const fUrl  = packed.urls;
  const fName = packed.names;
  const fMime = packed.mimes;

  const timestamp = now();

  // ★ 재제출(반려 후 다시 냄)이면 기존 제출 행을 갱신하고 반려 기록을 지운다.
  //   이전에는 행을 새로 추가만 하고 반려 기록을 그대로 둬서,
  //   학생이 다시 냈는데도 화면에 계속 '반려'로 표시됐다.
  let updatedExisting = false;
  for (let i = 1; i < subData.length; i++) {
    if (ownsRow(who, subData[i][0], subData[i][1]) &&
        String(subData[i][2]) === String(assignment_id)) {
      const r = i + 1;
      // ★ 학번 표기가 예전 값(코드 등)으로 남아 있으면 지금 기준으로 맞춰 둔다
      if (String(subData[i][0]).trim() !== studentNumber) subSheet.getRange(r, 1).setValue(studentNumber);
      subSheet.getRange(r, 4).setValue(content);
      subSheet.getRange(r, 5).setValue(fUrl);
      subSheet.getRange(r, 6).setValue(timestamp);
      subSheet.getRange(r, 7).setValue(fName);
      subSheet.getRange(r, 8).setValue(fMime);
      updatedExisting = true;
      break;
    }
  }
  if (updatedExisting) {
    clearFeedbackRow(assignment_id, who);
    return { success: true, message: "재제출 완료!" };
  }

  subSheet.appendRow([studentNumber, studentNameResolved, assignment_id, content, fUrl, timestamp, fName, fMime]);
  forceTextColumn(subSheet, 6);

  // ★ 클래스별 제출물 시트에도 동시 기록
  try {
    if (who.cls) {
      const classSubSheet = getSS().getSheetByName(who.cls + " 제출물");
      if (classSubSheet) {
        classSubSheet.appendRow([studentNumber, studentNameResolved, assignment_id, content, fUrl, timestamp, fName, fMime]);
      }
    }
  } catch(e) { /* 클래스 시트 기록 실패해도 메인 시트엔 저장됨 */ }

  return { success: true, message: "제출 완료!" };
}

// ── 반려 기록 삭제 (재제출 시) ─────────────────────
// 메인 피드백 시트와 클래스별 피드백 시트 양쪽에서 해당 행을 지운다.
// who: whoOf()가 만든 학생 정보 (학번·코드 어느 표기로 저장돼 있어도 찾아낸다)
function clearFeedbackRow(assignment_id, who) {
  try {
    const ss = getSS();
    const sheets = [ss.getSheetByName(SHEET.피드백)];
    ss.getSheets().forEach(function(sh) {
      if (sh.getName().endsWith(" 피드백")) sheets.push(sh);
    });
    sheets.forEach(function(sh) {
      if (!sh) return;
      const d = sh.getDataRange().getValues();
      for (let i = d.length - 1; i >= 1; i--) {
        if (String(d[i][0]) === String(assignment_id) &&
            ownsRow(who, d[i][1], d[i][2])) {
          sh.deleteRow(i + 1);
        }
      }
    });
  } catch(e) { /* 실패해도 제출 자체는 이미 저장됨 */ }
}

// ── 교사 로그인 ──────────────────────────────────
function teacherLogin(password) {
  if (!password) return { success: false, message: "비밀번호를 입력해주세요." };
  const correctPw = getTeacherPassword();
  if (password !== correctPw) return { success: false, message: "비밀번호가 틀렸습니다." };
  return { success: true, teacherName: getTeacherName(), theme: getDesignTheme() };
}

// ── 전체 제출물 조회 (교사) ──────────────────────
function getAllSubmissions(password, assignment_id, student_code) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };

  const subSheet = getSheet(SHEET.제출물);
  const fbSheet  = getSheet(SHEET.피드백);
  if (!subSheet) return { success: true, submissions: [] };

  const subData = subSheet.getDataRange().getValues();
  const fbData  = fbSheet ? fbSheet.getDataRange().getValues() : [[]];

  const idx = buildStudentIndex();

  // 피드백맵: (과제ID_대표키) → 최신 피드백
  // 피드백 시트: 과제ID(0), 학번(1), 이름(2), 내용(3), 작성일시(4), 반려여부(5)
  const feedbackMap = {};
  for (let i = 1; i < fbData.length; i++) {
    if (!fbData[i][0]) continue;
    const key = String(fbData[i][0]) + "_" + canonKeyOf(idx, fbData[i][1], fbData[i][2]);
    if (!feedbackMap[key] || asTimeText(fbData[i][4]) > feedbackMap[key].created_at) {
      feedbackMap[key] = {
        content:     fbData[i][3],
        created_at:  asTimeText(fbData[i][4]),
        is_rejected: String(fbData[i][5]) === "반려",
        stamps:      parseStamp(fbData[i][6])
      };
    }
  }

  // ★ 특정 학생만 보려는 요청이면 반드시 그 학생으로 좁힌다.
  //   예전에는 학번 칸이 비어 있는 학생일 때 filterNumber가 ""(거짓값)이 되어
  //   필터가 통째로 무시됐고, 남의 제출물이 그 학생 화면에 떴다.
  //   교사가 거기에 피드백을 쓰면 엉뚱한 학생 앞으로 저장돼
  //   "저장은 됐다는데 학생에게는 안 보이는" 상태가 됐다.
  const who = student_code ? whoOf(student_code, idx) : null;

  // ★ 학생별 도장 누계 — 위에서 이미 피드백 시트를 다 읽어 뒀으므로 덤으로 얻는다.
  //   (시트 왕복이 늘지 않는다)
  const stampByKey = {};
  for (let i = 1; i < fbData.length; i++) {
    if (!fbData[i][0]) continue;
    const n = parseStamp(fbData[i][6]);
    if (!n) continue;
    const k = canonKeyOf(idx, fbData[i][1], fbData[i][2]);
    stampByKey[k] = (stampByKey[k] || 0) + n;
  }

  // 제출물 시트: 학번(0), 이름(1), 과제ID(2), 내용(3), 파일URL(4), 제출일시(5), 파일명(6), 파일형식(7)
  const submissions = [];
  for (let i = 1; i < subData.length; i++) {
    if (!subData[i][0]) continue;
    const num = String(subData[i][0]);
    if (assignment_id && String(subData[i][2]) !== String(assignment_id)) continue;
    if (who && !ownsRow(who, num, subData[i][1])) continue;
    const stu = studentOfRow(idx, num, subData[i][1]) ||
                { name: subData[i][1], class: "", code: "", number: num, canon: num };
    const key = String(subData[i][2]) + "_" + stu.canon;
    submissions.push({
      id:             "row_" + (i + 1),
      student_number: stu.number || num,
      student_name:   stu.name || subData[i][1],
      student_class:  stu.class,
      student_code:   stu.code,
      assignment_id:  String(subData[i][2]),
      content:        subData[i][3],
      file_url:       subData[i][4] || "",
      submitted_at:   asTimeText(subData[i][5]),
      file_name:      subData[i][6] || "",
      mime_type:      subData[i][7] || "",
      feedback:       feedbackMap[key] || null
    });
  }
  return { success: true, submissions, stamp_totals: stampByKey };
}

// 그 학생(학번·코드 어느 표기든)의 해당 과제 제출물이 시트에 있는지
// 제출물 시트: 학번(0), 이름(1), 과제ID(2), ...
function hasSubmissionOf(who, assignment_id) {
  const sh = getSheet(SHEET.제출물);
  if (!sh) return false;
  const d = sh.getDataRange().getValues();
  for (let i = 1; i < d.length; i++) {
    if (String(d[i][2]) === String(assignment_id) && ownsRow(who, d[i][0], d[i][1])) return true;
  }
  return false;
}

// ── 피드백 등록/수정 (교사) ──────────────────────
// 피드백 시트 열: A=과제ID, B=학번, C=이름, D=내용, E=작성일시, F=반려여부
function submitFeedback(password, submission_id, student_code, assignment_id, content, stamps) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  if (!content) return { success: false, message: "피드백 내용을 입력해주세요." };
  if (!student_code) return { success: false, message: "학생을 확인할 수 없습니다. 새로고침 후 다시 시도해주세요." };

  // 학번·이름 조회 (학번이 비어 있으면 6자리 코드가 키가 된다)
  const who = whoOf(student_code);
  const studentNumber = who.canon;
  const studentName   = who.name;

  const sheet = getSheet(SHEET.피드백);
  if (!sheet) return { success: false, message: "시트 초기화 오류입니다." };
  const data  = sheet.getDataRange().getValues();

  // ★ 이 학생의 제출물이 실제로 있는지 먼저 확인한다.
  //   없으면 학생 화면에 붙을 곳이 없는 피드백이므로, 조용히 저장하지 않고 알린다.
  if (!hasSubmissionOf(who, assignment_id)) {
    return { success: false, message: "이 학생의 제출물을 찾을 수 없어 피드백을 저장하지 않았습니다. 화면을 새로고침한 뒤 다시 시도해주세요." };
  }

  // 학생 클래스(수업장소) — 클래스별 시트 기록용
  const classFbSheet = who.cls
    ? getSS().getSheetByName(who.cls + " 피드백")
    : null;

  const timestamp = now();
  // 도장은 0~3개. 피드백을 고쳐 써도 누적되지 않고 이 값으로 덮어쓴다.
  // (그래야 피드백을 세 번 수정했다고 도장이 9개가 되는 일이 없다)
  const stampCount = parseStamp(stamps);

  // 같은 과제ID+학생 행이 있으면 내용·작성일시·도장만 갱신, 반려여부 초기화
  for (let i = 1; i < data.length; i++) {
    if (String(data[i][0]) === String(assignment_id) &&
        ownsRow(who, data[i][1], data[i][2])) {
      // ★ 셀을 하나씩 쓰면 시트 왕복이 그만큼 늘어난다. 한 번에 묶어서 쓴다.
      //   (학번·이름·내용·작성일시·반려여부·도장 = B~G열)
      //   예전 표기(코드 등)로 남아 있던 학번도 이 김에 지금 기준으로 맞춰진다.
      sheet.getRange(i+1, 2, 1, 6).setValues([[
        studentNumber, data[i][2], content, timestamp, "정상", stampCount
      ]]);
      syncClassFeedback(classFbSheet, assignment_id, who, studentNumber, studentName, content, timestamp, "정상", stampCount);
      return { success: true, message: stampCount > 0
        ? "피드백이 수정되었습니다. (도장 " + stampCount + "개)"
        : "피드백이 수정되었습니다." };
    }
  }

  sheet.appendRow([assignment_id, studentNumber, studentName, content, timestamp, "정상", stampCount]);
  syncClassFeedback(classFbSheet, assignment_id, who, studentNumber, studentName, content, timestamp, "정상", stampCount);
  return { success: true, message: stampCount > 0
    ? "피드백이 등록되었습니다. (도장 " + stampCount + "개)"
    : "피드백이 등록되었습니다." };
}

// ── 클래스별 피드백 시트 동기화 ───────────────────
// 메인 피드백 시트와 같은 내용을 클래스 시트에도 맞춰 둔다.
// (교사가 반별 시트를 열어볼 때 쓰는 사본이라, 실패해도 학생 화면에는 영향이 없다)
function syncClassFeedback(classFbSheet, assignment_id, who, studentNumber, studentName, content, timestamp, status, stampCount) {
  if (!classFbSheet) return;
  const stamp = parseStamp(stampCount);
  try {
    const clsData = classFbSheet.getDataRange().getValues();
    for (let j = 1; j < clsData.length; j++) {
      if (String(clsData[j][0]) === String(assignment_id) && ownsRow(who, clsData[j][1], clsData[j][2])) {
        // 메인 시트와 마찬가지로 B~G열을 한 번에 쓴다 (왕복 4회 → 1회)
        classFbSheet.getRange(j+1, 2, 1, 6).setValues([[
          studentNumber, clsData[j][2], content, timestamp, status, stamp
        ]]);
        return;
      }
    }
    classFbSheet.appendRow([assignment_id, studentNumber, studentName, content, timestamp, status, stamp]);
  } catch(e) { /* 클래스 시트 기록 실패해도 메인 시트엔 저장됨 */ }
}

// ── 반려 처리 (교사) ─────────────────────────────
function rejectSubmission(password, submission_id, student_code, assignment_id) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  if (!student_code) return { success: false, message: "학생을 확인할 수 없습니다. 새로고침 후 다시 시도해주세요." };

  // 학번·이름 조회 (학번이 비어 있으면 6자리 코드가 키가 된다)
  const who = whoOf(student_code);
  const studentNumber = who.canon;
  const studentName   = who.name;

  const sheet = getSheet(SHEET.피드백);
  if (!sheet) return { success: false, message: "시트 초기화 오류입니다." };
  const data = sheet.getDataRange().getValues();
  const msg  = "⚠️ 반려됨 — 내용을 수정하여 재제출해 주세요. 궁금한 점은 선생님께 문의하세요.";

  // ★ 반려할 제출물이 실제로 있는지 확인 (없으면 학생 화면에 붙을 곳이 없다)
  if (!hasSubmissionOf(who, assignment_id)) {
    return { success: false, message: "이 학생의 제출물을 찾을 수 없습니다. 화면을 새로고침한 뒤 다시 시도해주세요." };
  }

  const classFbSheet = who.cls
    ? getSS().getSheetByName(who.cls + " 피드백")
    : null;

  const timestamp = now();

  for (let i = 1; i < data.length; i++) {
    if (String(data[i][0]) === String(assignment_id) &&
        ownsRow(who, data[i][1], data[i][2])) {
      // 반려하면 그 과제로 준 도장도 함께 회수한다 (B~G열 한 번에 쓰기)
      sheet.getRange(i+1, 2, 1, 6).setValues([[
        studentNumber, data[i][2], msg, timestamp, "반려", 0
      ]]);
      syncClassFeedback(classFbSheet, assignment_id, who, studentNumber, studentName, msg, timestamp, "반려", 0);
      return { success: true, message: "반려 처리되었습니다." };
    }
  }

  sheet.appendRow([assignment_id, studentNumber, studentName, msg, timestamp, "반려", 0]);
  syncClassFeedback(classFbSheet, assignment_id, who, studentNumber, studentName, msg, timestamp, "반려", 0);
  return { success: true, message: "반려 처리되었습니다." };
}

// ── 전체 피드백 조회 (교사) ──────────────────────
// 피드백 시트: A=과제ID, B=학번, C=이름, D=내용, E=작성일시, F=반려여부
function getAllFeedbacks(password, assignment_id, student_code) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  const sheet = getSheet(SHEET.피드백);
  if (!sheet) return { success: true, feedbacks: [] };

  // ★ student_code → 그 학생이 쓸 수 있는 표기(학번·코드) 전부.
  //   예전에는 학번만 봤기 때문에, 학번 칸이 빈 학생이면 필터가 통째로 무시돼
  //   다른 학생의 피드백까지 섞여 나왔다.
  const who = student_code ? whoOf(student_code) : null;

  const data = sheet.getDataRange().getValues();
  const feedbacks = [];
  for (let i = 1; i < data.length; i++) {
    if (!data[i][0]) continue;
    // ★ 문자열로 맞춰서 비교한다. 학번이 숫자로 저장돼 있으면
    //   10101 !== "10101" 이 항상 참이라 결과가 늘 비어 나왔다.
    if (assignment_id && String(data[i][0]) !== String(assignment_id)) continue;
    if (who && !ownsRow(who, data[i][1], data[i][2])) continue;
    feedbacks.push({
      assignment_id: String(data[i][0]),
      student_number:data[i][1],
      student_name:  data[i][2],
      content:       data[i][3],
      created_at:    asTimeText(data[i][4]),
      is_rejected:   String(data[i][5]) === "반려",
      stamps:        parseStamp(data[i][6])
    });
  }
  return { success: true, feedbacks };
}

// ── 과제 추가 (교사) ─────────────────────────────
// 과제목록 시트 열: A=과제ID, B=제목, C=설명, D=마감일, E=등록일시, F=대상수업, G=파일URL, H=파일명, I=파일형식
function addAssignment(password, title, description, due_date, class_target, file_url) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  if (!title) return { success: false, message: "과제명을 입력해주세요." };

  const sheet = getSheet(SHEET.과제목록);
  if (!sheet) return { success: false, message: "시트 초기화 오류입니다." };

  const packed = splitFileParam(file_url);
  const fUrl  = packed.urls;
  const fName = packed.names;
  const fMime = packed.mimes;

  // ★ 과제ID는 시간 기반으로 만든다.
  //   이전에는 getLastRow() 기반이라, 과제를 지운 뒤 새로 추가하면
  //   이미 존재하는 ID가 다시 발급되어 제출물·피드백이 엉뚱한 과제에 붙었다.
  //   (기존 A001 형식 데이터와 섞여도 문자열 비교라 문제없다)
  const id = makeAssignmentId(sheet);
  // ★ appendRow로 그냥 쓰면 대상수업("3-1")·마감일이 날짜로 자동 변환된다.
  //   그러면 학생의 수업장소와 값이 달라져 학생 화면에 과제가 뜨지 않았다.
  //   행 전체를 텍스트 서식으로 고정한 뒤 값을 넣는다.
  const newRow = sheet.getLastRow() + 1;
  const range  = sheet.getRange(newRow, 1, 1, 9);
  range.setNumberFormat("@");
  range.setValues([[id, title, description||"", due_date||"", now(),
                    classText(class_target), fUrl, fName, fMime]]);
  try { sheet.autoResizeColumns(1, sheet.getLastColumn()); } catch(e) {}
  return { success: true, message: "과제가 등록되었습니다.", id };
}

// ── 과제 수정 (교사) ─────────────────────────────
// 과제목록 시트 열: A=과제ID, B=제목, C=설명, D=마감일, E=등록일시, F=대상수업, G=파일URL, H=파일명, I=파일형식
function updateAssignment(password, assignment_id, title, description, due_date, class_target, file_url, keep_file) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  if (!assignment_id) return { success: false, message: "과제ID가 필요합니다." };
  if (!title) return { success: false, message: "과제명을 입력해주세요." };

  const sheet = getSheet(SHEET.과제목록);
  if (!sheet) return { success: false, message: "시트 초기화 오류입니다." };

  const data = sheet.getDataRange().getValues();
  for (let i = 1; i < data.length; i++) {
    if (String(data[i][0]) !== String(assignment_id)) continue;

    const packed = splitFileParam(file_url);
    const fUrl  = packed.urls;
    const fName = packed.names;
    const fMime = packed.mimes;

    sheet.getRange(i+1, 2).setValue(title);
    sheet.getRange(i+1, 3).setValue(description || "");
    // ★ 마감일·대상수업은 텍스트 서식을 먼저 지정한다.
    //   안 그러면 "3-1" 같은 반 이름이 날짜로 바뀌어 저장돼,
    //   수정한 순간부터 그 반 학생에게 과제가 사라진다.
    sheet.getRange(i+1, 4).setNumberFormat("@").setValue(due_date || "");
    sheet.getRange(i+1, 6).setNumberFormat("@").setValue(classText(class_target));

    // ★ 첨부 처리
    //   keep_file="1" → 기존 첨부 유지 (새 파일을 올리지 않은 경우)
    //   그 외          → 전달된 값으로 교체. 빈 값이면 첨부 제거.
    //   이전에는 file_url이 항상 문자열이라 조건이 늘 참이었고,
    //   그래서 첨부만 떼어낼 방법이 아예 없었다.
    if (String(keep_file) !== "1") {
      sheet.getRange(i+1, 7).setValue(fUrl);
      sheet.getRange(i+1, 8).setValue(fName);
      sheet.getRange(i+1, 9).setValue(fMime);
    }

    return { success: true, message: "과제가 수정되었습니다." };
  }
  return { success: false, message: "과제를 찾을 수 없습니다." };
}

// ── 과제 삭제 (교사) ─────────────────────────────
// 과제 행 삭제 + 해당 과제ID의 제출물·피드백 행도 모두 삭제
function deleteAssignment(password, assignment_id) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  if (!assignment_id) return { success: false, message: "과제ID가 필요합니다." };

  const ss = getSS();

  // 1) 과제목록 시트에서 해당 행 삭제
  const aSheet = getSheet(SHEET.과제목록);
  if (aSheet) {
    const aData = aSheet.getDataRange().getValues();
    for (let i = aData.length - 1; i >= 1; i--) {
      if (String(aData[i][0]) === String(assignment_id)) {
        aSheet.deleteRow(i + 1);
        break;
      }
    }
  }

  // 2) 제출물 시트에서 해당 과제ID 행 모두 삭제 (뒤에서부터)
  // 제출물 시트: 학번(0), 이름(1), 과제ID(2), ...
  const subSheet = getSheet(SHEET.제출물);
  if (subSheet) {
    const subData = subSheet.getDataRange().getValues();
    for (let i = subData.length - 1; i >= 1; i--) {
      if (String(subData[i][2]) === String(assignment_id)) {
        subSheet.deleteRow(i + 1);
      }
    }
  }

  // 3) 피드백 시트에서 해당 과제ID 행 모두 삭제
  // 피드백 시트: 과제ID(0), 학번(1), ...
  const fbSheet = getSheet(SHEET.피드백);
  if (fbSheet) {
    const fbData = fbSheet.getDataRange().getValues();
    for (let i = fbData.length - 1; i >= 1; i--) {
      if (String(fbData[i][0]) === String(assignment_id)) {
        fbSheet.deleteRow(i + 1);
      }
    }
  }

  // 4) 클래스별 제출물·피드백 시트에서도 삭제
  const allSheets = ss.getSheets();
  for (const sh of allSheets) {
    const shName = sh.getName();
    if (shName.endsWith(" 제출물")) {
      // 클래스 제출물 시트: 과제ID 열은 3번째(index 2)
      const d = sh.getDataRange().getValues();
      for (let i = d.length - 1; i >= 1; i--) {
        if (String(d[i][2]) === String(assignment_id)) sh.deleteRow(i + 1);
      }
    } else if (shName.endsWith(" 피드백")) {
      // 클래스 피드백 시트: 과제ID 열은 1번째(index 0)
      const d = sh.getDataRange().getValues();
      for (let i = d.length - 1; i >= 1; i--) {
        if (String(d[i][0]) === String(assignment_id)) sh.deleteRow(i + 1);
      }
    }
  }

  return { success: true, message: "과제와 관련 제출물이 모두 삭제되었습니다." };
}

// ── 학생 추가 (교사) ─────────────────────────────
function addStudent(password, name, class_name, number) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  if (!name || !class_name) return { success: false, message: "수업장소와 이름을 입력해주세요." };

  const sheet = getSheet(SHEET.학생목록);
  if (!sheet) return { success: false, message: "시트 초기화 오류입니다." };

  const data = sheet.getDataRange().getValues();
  const existingCodes = collectExistingCodes(data);   // ★ 코드 열(4번째)을 본다
  let code;
  do { code = generateCode(); } while (existingCodes.includes(code));

  // ★ 수업장소(1열)를 텍스트 형식으로 강제 지정 — "3-1" 같은 값이 날짜로 자동 변환되는 것을 방지
  const newRow = sheet.getLastRow() + 1;
  const range = sheet.getRange(newRow, 1, 1, 5);
  range.setNumberFormat("@");
  range.setValues([[classText(class_name), number||"", name, code, now()]]);
  try { sheet.setColumnWidth(1,160); sheet.setColumnWidth(2,120); sheet.setColumnWidth(3,140); sheet.setColumnWidth(4,120); sheet.setColumnWidth(5,180); } catch(e) {}

  // 학생 드라이브 폴더 미리 생성
  try { getStudentFolder(name); } catch(e) {}

  return { success: true, message: "학생이 등록되었습니다.", code };
}

// ── 학생 일괄 추가 (교사) ────────────────────────
function bulkAddStudents(password, students_json, class_name) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  if (!class_name) return { success: false, message: "클래스를 선택해주세요." };
  let students;
  try { students = JSON.parse(students_json); } catch(e) { return { success: false, message: "학생 데이터 파싱 오류" }; }
  if (!Array.isArray(students) || !students.length) return { success: false, message: "학생 정보가 없습니다." };

  const sheet = getSheet(SHEET.학생목록);
  if (!sheet) return { success: false, message: "시트 초기화 오류입니다." };

  const data = sheet.getDataRange().getValues();
  const existingCodes = collectExistingCodes(data);   // ★ 코드 열(4번째)을 본다

  const results = [];
  for (const s of students) {
    const name = String(s.name || "").trim();
    const number = String(s.number || "").trim();
    if (!name) continue;
    let code;
    do { code = generateCode(); } while (existingCodes.includes(code));
    existingCodes.push(code);
    // ★ 수업장소(1열)를 텍스트 형식으로 강제 지정 — "3-1" 같은 값이 날짜로 자동 변환되는 것을 방지
    const newRow = sheet.getLastRow() + 1;
    const range = sheet.getRange(newRow, 1, 1, 5);
    range.setNumberFormat("@");
    range.setValues([[classText(class_name), number, name, code, now()]]);
    try { getStudentFolder(name); } catch(e) {}
    results.push({ name, code, number });
  }
  try { sheet.setColumnWidth(1,160); sheet.setColumnWidth(2,120); sheet.setColumnWidth(3,140); sheet.setColumnWidth(4,120); sheet.setColumnWidth(5,180); } catch(e) {}
  return { success: true, count: results.length, results };
}

// ── 학생 목록 조회 (교사) ────────────────────────
function getStudents(password) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  const sheet = getSheet(SHEET.학생목록);
  if (!sheet) return { success: true, students: [] };
  // ★ 수업장소 열(A열)을 텍스트 형식으로 설정 — 기존 셀도 포함
  const lastRow = sheet.getLastRow();
  if (lastRow >= 2) sheet.getRange(2, 1, lastRow - 1, 1).setNumberFormat("@");
  const data = sheet.getDataRange().getValues();
  const students = [];
  for (let i = 1; i < data.length; i++) {
    if (!data[i][3]) continue;  // 코드(4열)가 없으면 skip
    students.push({
      class:      classText(data[i][0]),
      number:     String(data[i][1] || ""),
      name:       String(data[i][2]),
      code:       String(data[i][3]),
      created_at: String(data[i][4] || "")
    });
  }
  return { success: true, students };
}

// ── 학생 이름 수정 (교사) ────────────────────────
// 이름은 학생목록뿐 아니라 제출물·피드백 시트와 드라이브의 학생 폴더에도 그대로
// 남아 있다. 학생목록만 고치면 예전 제출물이 옛 이름으로 남아 다른 사람처럼 보이고
// 새 제출물은 새 폴더로 들어가 자료가 두 곳으로 갈라진다. 그래서 이름이 적힌 곳을
// 모두 함께 바꿔준다. (학생을 찾는 기준은 이름이 아니라 6자리 코드이므로,
//  이름이 바뀌어도 제출물·피드백 연결은 끊기지 않는다)
function renameStudent(password, code, newName) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  const key = String(code == null ? "" : code).trim();
  if (!key) return { success: false, message: "학생을 찾을 수 없습니다." };
  const trimmed = String(newName == null ? "" : newName).trim();
  if (!trimmed) return { success: false, message: "이름을 입력해주세요." };

  const sheet = getSheet(SHEET.학생목록);
  if (!sheet) return { success: false, message: "시트 초기화 오류입니다." };

  // 학생목록 열: 수업장소(0) · 학번(1) · 이름(2) · 코드(3) · 등록일시(4)
  const data = sheet.getDataRange().getValues();
  let rowIdx = -1, oldName = "";
  for (let i = 1; i < data.length; i++) {
    if (String(data[i][3] || "").trim().toUpperCase() === key.toUpperCase()) {
      rowIdx = i + 1;
      oldName = String(data[i][2] || "");
      break;
    }
  }
  if (rowIdx < 0) return { success: false, message: "학생을 찾을 수 없습니다." };
  if (oldName === trimmed) return { success: true, message: "변경할 내용이 없습니다.", name: trimmed, updated: 0 };

  // ★ 이름을 바꾸기 전에 이 학생의 식별 정보를 먼저 잡아둔다.
  //   학번을 반 번호(1,2,3…)로 넣어 학번이 겹치는 반에서는 옛 이름으로 행을 가려야 하는데,
  //   시트를 먼저 고치면 그 기준이 사라진다.
  const who = whoOf(key);

  // 1) 학생목록의 이름(3열)
  const nameCell = sheet.getRange(rowIdx, 3);
  nameCell.setNumberFormat("@");
  nameCell.setValue(trimmed);

  // 2) 제출물·피드백 시트에 남은 이름 (메인 시트 + 클래스별 시트)
  //    제출물: 학번(1열)·이름(2열) / 피드백: 과제ID(1열)·학번(2열)·이름(3열)
  let updated = 0;
  const ss = getSS();
  const targets = [];
  const mainSub = ss.getSheetByName(SHEET.제출물);
  const mainFb  = ss.getSheetByName(SHEET.피드백);
  if (mainSub) targets.push({ sh: mainSub, keyCol: 1, nameCol: 2 });
  if (mainFb)  targets.push({ sh: mainFb,  keyCol: 2, nameCol: 3 });
  ss.getSheets().forEach(function (sh) {
    const n = sh.getName();
    if (n.endsWith(" 제출물"))      targets.push({ sh: sh, keyCol: 1, nameCol: 2 });
    else if (n.endsWith(" 피드백")) targets.push({ sh: sh, keyCol: 2, nameCol: 3 });
  });
  targets.forEach(function (t) {
    try {
      const last = t.sh.getLastRow();
      if (last < 2) return;
      const keys  = t.sh.getRange(2, t.keyCol,  last - 1, 1).getValues();
      const range = t.sh.getRange(2, t.nameCol, last - 1, 1);
      const names = range.getValues();
      let touched = false;
      for (let i = 0; i < keys.length; i++) {
        if (!ownsRow(who, keys[i][0], names[i][0])) continue;
        if (String(names[i][0]) === trimmed) continue;
        names[i][0] = trimmed;
        touched = true;
        updated++;
      }
      if (touched) { range.setNumberFormat("@"); range.setValues(names); }
    } catch (e) { /* 한 시트가 실패해도 나머지는 계속 바꾼다 */ }
  });

  // 3) 드라이브의 학생 폴더 이름 (제출물_학생/이름)
  //    새 이름의 폴더가 이미 있으면 파일이 섞이지 않도록 건드리지 않는다.
  try {
    if (oldName) {
      const studentRoot = getStudentFolder("");
      const olds = studentRoot.getFoldersByName(oldName);
      if (olds.hasNext() && !studentRoot.getFoldersByName(trimmed).hasNext()) {
        olds.next().setName(trimmed);
      }
    }
  } catch (e) { /* 폴더 정리에 실패해도 이름 변경 자체는 끝났다 */ }

  return {
    success: true,
    message: updated
      ? "이름이 변경되었습니다. (제출·피드백 기록 " + updated + "건 함께 갱신)"
      : "이름이 변경되었습니다.",
    name: trimmed,
    old_name: oldName,
    updated: updated
  };
}

// ── 제출물 검색 (반별·학생별, 교사용) ───────────
function searchSubmissions(password, class_name, student_name, assignment_id) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };

  const subSheet = getSheet(SHEET.제출물);
  const fbSheet  = getSheet(SHEET.피드백);
  if (!subSheet) return { success: true, submissions: [] };

  const subData = subSheet.getDataRange().getValues();
  const fbData  = fbSheet  ? fbSheet.getDataRange().getValues()  : [[]];

  const idx = buildStudentIndex();

  // 피드백 맵: (과제ID_대표키) → 최신 피드백
  // 피드백 시트: 과제ID(0), 학번(1), 이름(2), 내용(3), 작성일시(4), 반려여부(5)
  const feedbackMap = {};
  for (let i = 1; i < fbData.length; i++) {
    if (!fbData[i][0]) continue;
    const key = String(fbData[i][0]) + "_" + canonKeyOf(idx, fbData[i][1], fbData[i][2]);
    if (!feedbackMap[key] || asTimeText(fbData[i][4]) > feedbackMap[key].created_at) {
      feedbackMap[key] = {
        content:     fbData[i][3],
        created_at:  asTimeText(fbData[i][4]),
        is_rejected: String(fbData[i][5]) === "반려"
      };
    }
  }

  // 제출물 시트: 학번(0), 이름(1), 과제ID(2), 내용(3), 파일URL(4), 제출일시(5), 파일명(6), 파일형식(7)
  const submissions = [];
  for (let i = 1; i < subData.length; i++) {
    if (!subData[i][0]) continue;
    const num  = String(subData[i][0]);
    const stu  = studentOfRow(idx, num, subData[i][1]) ||
                 { name: String(subData[i][1] || ""), class: "", number: num, code: "", canon: num };

    if (class_name   && !sameClass(stu.class, class_name)) continue;
    if (student_name && String(stu.name).indexOf(student_name) < 0) continue;
    if (assignment_id && String(subData[i][2]) !== String(assignment_id)) continue;

    const key = String(subData[i][2]) + "_" + stu.canon;
    submissions.push({
      id:             "row_" + (i + 1),
      student_number: stu.number || num,
      student_name:   stu.name,
      student_class:  stu.class,
      student_code:   stu.code,
      assignment_id:  String(subData[i][2]),
      content:        subData[i][3],
      file_url:       subData[i][4] || "",
      submitted_at:   asTimeText(subData[i][5]),
      file_name:      subData[i][6] || "",
      mime_type:      subData[i][7] || "",
      feedback:       feedbackMap[key] || null
    });
  }

  submissions.sort((a,b) => b.submitted_at.toString().localeCompare(a.submitted_at.toString()));
  return { success: true, submissions, total: submissions.length };
}

// ── 수동 초기화 함수 (최초 1회 실행 권장) ─────────
function setupSpreadsheet() {
  const props = PropertiesService.getScriptProperties();
  try { props.deleteProperty(SETUP_FLAG); } catch(e) {}

  // ★ 이 시트에서 실행됐다면 그 시트를 연결 대상으로 못박아 둔다.
  //   이후 코드를 최신본으로 붙여넣어도 연결이 유지된다.
  try {
    const active = SpreadsheetApp.getActiveSpreadsheet();
    if (active) props.setProperty(PROP_SS_ID, active.getId());
  } catch(e) {}

  initSheets();
  normalizeTimeColumns();
  try { props.setProperty(SETUP_FLAG, "1"); } catch(e) {}

  const ss = getSS();
  ss.toast("✅ 시트 초기화 완료!", "Done? Done!", 5);
  try {
    SpreadsheetApp.getUi().alert(
      "Done? Done! 최초 설정 완료",
      "✅ 이 스프레드시트에 연결되었습니다.\n\n• " + ss.getName() + "\n\n" +
      "앞으로 코드를 최신본으로 붙여넣어도 이 연결은 유지됩니다.\n" +
      "이제 [배포] → [배포 관리] → 새 버전으로 배포하시면 됩니다.",
      SpreadsheetApp.getUi().ButtonSet.OK);
  } catch(e) {}
}

// ══════════════════════════════════════════════════
// ██ 기존 사용자용 — 데이터 이어쓰기 / 가져오기 ██
// ══════════════════════════════════════════════════
//
//  ① 쓰던 시트를 그대로 계속 쓰는 경우
//     → Code.gs만 이 최신본으로 교체한 뒤 upgradeExisting() 1회 실행
//
//  ② 새 스프레드시트로 옮기고 싶은 경우
//     → 새 시트에 이 코드를 넣고 SPREADSHEET_ID를 새 시트로 지정한 뒤,
//       importFromOldSpreadsheet("예전_시트_ID") 실행
//
// ══════════════════════════════════════════════════

/**
 * ① 기존 시트를 그대로 이어서 쓰기 위한 점검·보정.
 *    Apps Script 편집기에서 함수 목록에서 골라 ▶ 실행하면 된다.
 *    · 없는 시트 생성
 *    · 시각 열을 텍스트 서식으로 고정 (9시간 밀리는 문제 예방)
 *    · 과제ID 중복 정리 (예전 버그로 생긴 것)
 *    · 학생 코드 중복 정리
 *    여러 번 실행해도 안전하다.
 */
function upgradeExisting() {
  const report = [];
  try { PropertiesService.getScriptProperties().deleteProperty(SETUP_FLAG); } catch(e) {}

  initSheets();
  report.push("• 시트 구조 확인 완료");

  normalizeTimeColumns();
  report.push("• 날짜·시각 열을 텍스트 서식으로 고정");

  const dupA = fixDuplicateAssignmentIds();
  report.push("• 중복 과제ID 정리: " + dupA + "건");

  const dupC = fixDuplicateStudentCodes();
  report.push("• 중복 학생코드 재발급: " + dupC + "건");

  try { PropertiesService.getScriptProperties().setProperty(SETUP_FLAG, "1"); } catch(e) {}

  const msg = "✅ 기존 데이터를 그대로 사용할 준비가 끝났습니다.\n\n" + report.join("\n") +
              "\n\n학생들이 쓰던 6자리 코드는 그대로 유지됩니다.\n" +
              "(중복이 발견된 코드만 새로 발급되며, 아래 목록을 확인하세요)";
  try {
    SpreadsheetApp.getUi().alert("Done? Done! 업그레이드 완료", msg, SpreadsheetApp.getUi().ButtonSet.OK);
  } catch(e) {
    Logger.log(msg);
  }
  return msg;
}

/**
 * 예전 버그(행 번호 기반 ID)로 같은 과제ID가 둘 이상 생겼을 때,
 * 뒤쪽 과제에 새 ID를 발급하고 그 과제의 제출물·피드백도 함께 옮긴다.
 */
function fixDuplicateAssignmentIds() {
  const ss = getSS();
  const sheet = ss.getSheetByName(SHEET.과제목록);
  if (!sheet) return 0;

  const data = sheet.getDataRange().getValues();
  const seen = {};
  let fixed = 0;

  for (let i = 1; i < data.length; i++) {
    const id = String(data[i][0] || "");
    if (!id) continue;
    if (!seen[id]) { seen[id] = i; continue; }

    // 중복 발견 — 뒤에 나온 행에 새 ID를 준다
    const newId = "A" + new Date().getTime() + "_" + fixed;
    sheet.getRange(i + 1, 1).setValue(newId);

    // 제출일시를 기준으로 어느 제출물이 이 과제 것인지 가릴 수 없으므로,
    // 안전하게 "등록일시가 더 늦은 과제" 쪽 제출물만 옮기지 않고 그대로 둔다.
    // 대신 관리자가 알아볼 수 있게 제목에 표시를 남긴다.
    const title = String(data[i][1] || "");
    if (title.indexOf("[ID중복정리]") < 0) {
      sheet.getRange(i + 1, 2).setValue("[ID중복정리] " + title);
    }
    fixed++;
  }
  return fixed;
}

/**
 * 예전 버그(엉뚱한 열을 보던 중복 검사)로 같은 코드를 받은 학생이 있으면
 * 뒤쪽 학생에게 새 코드를 발급한다. 앞선 학생의 코드는 그대로 유지된다.
 */
function fixDuplicateStudentCodes() {
  const ss = getSS();
  const sheet = ss.getSheetByName(SHEET.학생목록);
  if (!sheet) return 0;

  const data = sheet.getDataRange().getValues();
  const seen = {};
  const all = collectExistingCodes(data);
  let fixed = 0;

  for (let i = 1; i < data.length; i++) {
    const code = String(data[i][3] || "").trim().toUpperCase();
    if (!code) {
      // 코드가 비어 있는 학생에게도 새로 발급
      let c; do { c = generateCode(); } while (all.includes(c));
      all.push(c);
      sheet.getRange(i + 1, 4).setValue(c);
      fixed++;
      continue;
    }
    if (!seen[code]) { seen[code] = true; continue; }
    let c; do { c = generateCode(); } while (all.includes(c));
    all.push(c); seen[c] = true;
    sheet.getRange(i + 1, 4).setValue(c);
    fixed++;
  }
  return fixed;
}

/**
 * ② 예전 스프레드시트의 내용을 지금 시트로 가져온다.
 *    Apps Script 편집기에서 아래처럼 ID를 넣어 실행:
 *      function run() { importFromOldSpreadsheet("예전_시트_ID"); }
 *
 *    · 학생의 6자리 코드는 그대로 유지된다
 *    · 이미 있는 항목은 건너뛰므로 여러 번 실행해도 중복되지 않는다
 *    · 과제ID도 원본 그대로 옮겨 제출물·피드백 연결이 유지된다
 */
function importFromOldSpreadsheet(oldSpreadsheetId) {
  if (!oldSpreadsheetId) {
    throw new Error('예전 스프레드시트 ID를 넣어주세요. 예) importFromOldSpreadsheet("1AbC...")');
  }
  initSheets();

  const oldSs = SpreadsheetApp.openById(oldSpreadsheetId);
  const newSs = getSS();
  const stat = { 학생: 0, 과제: 0, 제출물: 0, 피드백: 0, 클래스: 0, 건너뜀: 0 };

  function rowsOf(ss, name) {
    const sh = ss.getSheetByName(name);
    if (!sh) return [];
    const d = sh.getDataRange().getValues();
    return d.length > 1 ? d.slice(1) : [];
  }
  function keyOf(arr) { return arr.map(function(v){ return String(v == null ? "" : v).trim(); }).join(""); }

  // ── 클래스목록 ──
  const clsSheet = newSs.getSheetByName(SHEET.클래스목록);
  const clsHave = {};
  rowsOf(newSs, SHEET.클래스목록).forEach(function(r){ clsHave[String(r[1]).trim()] = true; });
  rowsOf(oldSs, SHEET.클래스목록).forEach(function(r){
    const name = String(r[1] || "").trim();
    if (!name || clsHave[name]) { stat.건너뜀++; return; }
    clsHave[name] = true;
    const nr = clsSheet.getLastRow() + 1;
    const rg = clsSheet.getRange(nr, 1, 1, 3);
    rg.setNumberFormat("@");
    rg.setValues([[String(r[0] || ("CLS_" + new Date().getTime())), name, asTimeText(r[2]) || now()]]);
    // 클래스별 시트도 만들어 둔다
    if (!newSs.getSheetByName(name + " 제출물")) {
      const sh = newSs.insertSheet(name + " 제출물");
      sh.appendRow(["학번","이름","과제ID","내용","파일URL","제출일시","파일명","파일형식"]);
      styleHeader(sh);
    }
    if (!newSs.getSheetByName(name + " 피드백")) {
      const sh = newSs.insertSheet(name + " 피드백");
      sh.appendRow(["과제ID","학번","이름","내용","작성일시","반려여부","도장"]);
      styleHeader(sh);
    }
    stat.클래스++;
  });

  // ── 학생목록 (코드 기준 중복 회피, 코드는 원본 유지) ──
  const stuSheet = newSs.getSheetByName(SHEET.학생목록);
  const codeHave = {};
  rowsOf(newSs, SHEET.학생목록).forEach(function(r){
    const c = String(r[3] || "").trim().toUpperCase();
    if (c) codeHave[c] = true;
  });
  rowsOf(oldSs, SHEET.학생목록).forEach(function(r){
    const name = String(r[2] || "").trim();
    if (!name) { stat.건너뜀++; return; }
    let code = String(r[3] || "").trim().toUpperCase();
    if (!code || codeHave[code]) {
      if (code && codeHave[code]) { stat.건너뜀++; return; }   // 같은 코드면 이미 옮긴 학생
      do { code = generateCode(); } while (codeHave[code]);
    }
    codeHave[code] = true;
    const nr = stuSheet.getLastRow() + 1;
    const rg = stuSheet.getRange(nr, 1, 1, 5);
    rg.setNumberFormat("@");
    rg.setValues([[String(r[0] || ""), String(r[1] || ""), name, code, asTimeText(r[4]) || now()]]);
    stat.학생++;
  });

  // ── 과제목록 (과제ID 원본 유지) ──
  const aSheet = newSs.getSheetByName(SHEET.과제목록);
  const aHave = {};
  rowsOf(newSs, SHEET.과제목록).forEach(function(r){ aHave[String(r[0]).trim()] = true; });
  rowsOf(oldSs, SHEET.과제목록).forEach(function(r){
    const id = String(r[0] || "").trim();
    const title = String(r[1] || "").trim();
    if (!id || !title || aHave[id]) { stat.건너뜀++; return; }
    aHave[id] = true;
    const nr = aSheet.getLastRow() + 1;
    const rg = aSheet.getRange(nr, 1, 1, 9);
    rg.setNumberFormat("@");
    rg.setValues([[id, title, String(r[2] || ""), asTimeText(r[3]).slice(0,10),
                   asTimeText(r[4]) || now(), String(r[5] || ""),
                   String(r[6] || ""), String(r[7] || ""), String(r[8] || "")]]);
    stat.과제++;
  });

  // ── 제출물 (학번+과제ID 기준 중복 회피) ──
  const subSheet = newSs.getSheetByName(SHEET.제출물);
  const subHave = {};
  rowsOf(newSs, SHEET.제출물).forEach(function(r){ subHave[keyOf([r[0], r[2]])] = true; });
  rowsOf(oldSs, SHEET.제출물).forEach(function(r){
    const k = keyOf([r[0], r[2]]);
    if (!String(r[0] || "").trim() || !String(r[2] || "").trim() || subHave[k]) { stat.건너뜀++; return; }
    subHave[k] = true;
    const nr = subSheet.getLastRow() + 1;
    const rg = subSheet.getRange(nr, 1, 1, 8);
    rg.setNumberFormat("@");
    rg.setValues([[String(r[0]||""), String(r[1]||""), String(r[2]||""), String(r[3]||""),
                   String(r[4]||""), asTimeText(r[5]) || now(), String(r[6]||""), String(r[7]||"")]]);
    stat.제출물++;
  });

  // ── 피드백 (과제ID+학번 기준 중복 회피) ──
  const fbSheet = newSs.getSheetByName(SHEET.피드백);
  const fbHave = {};
  rowsOf(newSs, SHEET.피드백).forEach(function(r){ fbHave[keyOf([r[0], r[1]])] = true; });
  rowsOf(oldSs, SHEET.피드백).forEach(function(r){
    const k = keyOf([r[0], r[1]]);
    if (!String(r[0] || "").trim() || fbHave[k]) { stat.건너뜀++; return; }
    fbHave[k] = true;
    const nr = fbSheet.getLastRow() + 1;
    const rg = fbSheet.getRange(nr, 1, 1, 6);
    rg.setNumberFormat("@");
    rg.setValues([[String(r[0]||""), String(r[1]||""), String(r[2]||""), String(r[3]||""),
                   asTimeText(r[4]) || now(), String(r[5]||"")]]);
    stat.피드백++;
  });

  // ── 설정 (교사 비밀번호·성명·테마) ──
  try {
    const oldSet = oldSs.getSheetByName(SHEET.설정);
    const newSet = newSs.getSheetByName(SHEET.설정);
    if (oldSet && newSet) {
      const od = oldSet.getDataRange().getValues();
      const nd = newSet.getDataRange().getValues();
      for (let i = 1; i < od.length; i++) {
        const key = String(od[i][0] || "").trim();
        if (!key) continue;
        for (let j = 1; j < nd.length; j++) {
          if (String(nd[j][0]).trim() === key) {
            newSet.getRange(j + 1, 2).setValue(od[i][1]);
            break;
          }
        }
      }
    }
  } catch(e) {}

  normalizeTimeColumns();

  const msg = "✅ 예전 시트에서 데이터를 가져왔습니다.\n\n" +
    "• 클래스 " + stat.클래스 + "개\n" +
    "• 학생 " + stat.학생 + "명 (6자리 코드 그대로 유지)\n" +
    "• 과제 " + stat.과제 + "개\n" +
    "• 제출물 " + stat.제출물 + "건\n" +
    "• 피드백 " + stat.피드백 + "건\n" +
    "• 건너뜀 " + stat.건너뜀 + "건 (이미 있거나 내용이 비어 있음)\n\n" +
    "여러 번 실행해도 같은 자료가 중복 등록되지 않습니다.";
  try {
    SpreadsheetApp.getUi().alert("가져오기 완료", msg, SpreadsheetApp.getUi().ButtonSet.OK);
  } catch(e) {
    Logger.log(msg);
  }
  return msg;
}

// ── 사용설명서 강제 업데이트 (기존 시트 삭제 후 재생성) ──
// Apps Script 편집기에서 이 함수를 선택하고 ▶ 실행하세요.
function updateManualSheet() {
  const ss = getSS();
  const existing = ss.getSheetByName(SHEET.사용설명서);
  if (existing) {
    ss.deleteSheet(existing);
    SpreadsheetApp.flush();
  }
  createManualSheet(ss);
  ss.toast("✅ 사용설명서가 v2.0으로 업데이트되었습니다!", "Done? Done!", 5);
}

// ── 설정 조회 (인증 불필요 — 공개 정보만 반환) ────
function getSettings() {
  return {
    success: true,
    teacherName: getTeacherName(),
    theme: getDesignTheme()
  };
}

// ── 클래스 목록 조회 ───────────────────────────────
function getClasses(password) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  const sheet = getSheet(SHEET.클래스목록);
  if (!sheet) return { success: true, classes: [] };
  // ★ 클래스명 열(B열)을 텍스트 형식으로 설정 — 기존 셀도 포함
  const lastRow = sheet.getLastRow();
  if (lastRow >= 2) sheet.getRange(2, 2, lastRow - 1, 1).setNumberFormat("@");
  const data = sheet.getDataRange().getValues();
  const classes = [];
  for (let i = 1; i < data.length; i++) {
    if (!data[i][0]) continue;
    classes.push({ id: String(data[i][0]), name: classText(data[i][1]), created_at: String(data[i][2]) });
  }
  return { success: true, classes };
}

// ── 클래스 추가 ───────────────────────────────────
function addClassRoom(password, className) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  if (!className) return { success: false, message: "클래스명을 입력해주세요." };
  const sheet = getSheet(SHEET.클래스목록);
  if (!sheet) return { success: false, message: "시트 초기화 오류." };
  const data = sheet.getDataRange().getValues();
  for (let i = 1; i < data.length; i++) {
    if (sameClass(data[i][1], className))
      return { success: false, message: "이미 등록된 클래스명입니다." };
  }
  const id = "CLS_" + new Date().getTime();
  // ★ 클래스명(2열)을 텍스트 형식으로 강제 지정 — "3-1" 같은 값이 날짜로 자동 변환되는 것을 방지
  const newRow = sheet.getLastRow() + 1;
  const range = sheet.getRange(newRow, 1, 1, 3);
  range.setNumberFormat("@");
  range.setValues([[id, className.trim(), now()]]);

  // ★ 클래스별 제출물·피드백 시트 자동 생성
  const ss = getSS();
  const subSheetName = className.trim() + " 제출물";
  const fbSheetName  = className.trim() + " 피드백";

  if (!ss.getSheetByName(subSheetName)) {
    const subSh = ss.insertSheet(subSheetName);
    subSh.appendRow(["학번", "이름", "과제ID", "내용", "파일URL", "제출일시", "파일명", "파일형식"]);
    styleHeader(subSh);
  }
  if (!ss.getSheetByName(fbSheetName)) {
    const fbSh = ss.insertSheet(fbSheetName);
    fbSh.appendRow(["과제ID", "학번", "이름", "내용", "작성일시", "반려여부", "도장"]);
    styleHeader(fbSh);
  }

  return { success: true, message: "클래스가 추가되었습니다.", id };
}

// ── 클래스명 수정 ─────────────────────────────────
// 클래스명은 학생목록(수업장소)·과제목록(대상수업)·클래스별 시트 이름에도
// 그대로 쓰이므로, 이름만 바꾸면 학생과 과제가 클래스를 잃어버린다.
// 그래서 참조하는 곳을 모두 함께 바꿔준다.
function renameClassRoom(password, classId, newName) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  if (!classId)  return { success: false, message: "클래스를 찾을 수 없습니다." };
  const trimmed = String(newName == null ? "" : newName).trim();
  if (!trimmed) return { success: false, message: "클래스명을 입력해주세요." };

  const sheet = getSheet(SHEET.클래스목록);
  if (!sheet) return { success: false, message: "시트 초기화 오류." };
  const data = sheet.getDataRange().getValues();

  let rowIdx = -1, oldName = "";
  for (let i = 1; i < data.length; i++) {
    if (String(data[i][0]) === String(classId)) { rowIdx = i + 1; oldName = classText(data[i][1]); }
    else if (sameClass(data[i][1], trimmed)) {
      return { success: false, message: "이미 등록된 클래스명입니다." };
    }
  }
  if (rowIdx < 0) return { success: false, message: "클래스를 찾을 수 없습니다." };
  if (oldName === trimmed) return { success: true, message: "변경할 내용이 없습니다.", name: trimmed };

  // 1) 클래스목록 자체
  const nameCell = sheet.getRange(rowIdx, 2);
  nameCell.setNumberFormat("@");   // "3-1" 이 날짜로 바뀌는 것 방지
  nameCell.setValue(trimmed);

  // 2) 학생목록 A열(수업장소)
  let movedStudents = 0;
  const stuSheet = getSheet(SHEET.학생목록);
  if (stuSheet && stuSheet.getLastRow() >= 2) {
    const range = stuSheet.getRange(2, 1, stuSheet.getLastRow() - 1, 1);
    const vals = range.getValues();
    for (let i = 0; i < vals.length; i++) {
      if (sameClass(vals[i][0], oldName)) { vals[i][0] = trimmed; movedStudents++; }
    }
    if (movedStudents) { range.setNumberFormat("@"); range.setValues(vals); }
  }

  // 3) 과제목록 F열(대상수업)
  let movedAssigns = 0;
  const asgSheet = getSheet(SHEET.과제목록);
  if (asgSheet && asgSheet.getLastRow() >= 2) {
    const range = asgSheet.getRange(2, 6, asgSheet.getLastRow() - 1, 1);
    const vals = range.getValues();
    for (let i = 0; i < vals.length; i++) {
      if (sameClass(vals[i][0], oldName)) { vals[i][0] = trimmed; movedAssigns++; }
    }
    if (movedAssigns) { range.setNumberFormat("@"); range.setValues(vals); }
  }

  // 3-2) 학급공약 B열(클래스)
  //    여기를 안 바꾸면 이름을 바꾼 반의 공약과 도장 차감 내역이 통째로 사라진다.
  let movedPledges = 0;
  const pldSheet = getSheet(SHEET.학급공약);
  if (pldSheet && pldSheet.getLastRow() >= 2) {
    const range = pldSheet.getRange(2, 2, pldSheet.getLastRow() - 1, 1);
    const vals = range.getValues();
    for (let i = 0; i < vals.length; i++) {
      if (sameClass(vals[i][0], oldName)) { vals[i][0] = trimmed; movedPledges++; }
    }
    if (movedPledges) { range.setNumberFormat("@"); range.setValues(vals); }
  }

  // 4) 클래스별 제출물·피드백 시트 이름
  const ss = getSS();
  [["제출물"], ["피드백"]].forEach(function (pair) {
    const suffix = pair[0];
    const from = ss.getSheetByName(oldName + " " + suffix);
    if (from && !ss.getSheetByName(trimmed + " " + suffix)) {
      from.setName(trimmed + " " + suffix);
    }
  });

  return {
    success: true,
    message: "클래스명이 변경되었습니다. (학생 " + movedStudents + "명, 과제 " + movedAssigns +
             "개, 학급공약 " + movedPledges + "개 함께 갱신)",
    name: trimmed
  };
}

// ── 클래스 삭제 ───────────────────────────────────
// 학생·과제·제출물이 남아 있는 클래스를 지우면 생활기록부 자료가 통째로
// 사라질 수 있으므로, 무언가 남아 있으면 지우지 않고 무엇이 남았는지 알려준다.
function deleteClassRoom(password, classId) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  if (!classId) return { success: false, message: "클래스를 찾을 수 없습니다." };

  const sheet = getSheet(SHEET.클래스목록);
  if (!sheet) return { success: false, message: "시트 초기화 오류." };
  const data = sheet.getDataRange().getValues();

  let rowIdx = -1, name = "";
  for (let i = 1; i < data.length; i++) {
    if (String(data[i][0]) === String(classId)) { rowIdx = i + 1; name = classText(data[i][1]); break; }
  }
  if (rowIdx < 0) return { success: false, message: "클래스를 찾을 수 없습니다." };

  // 남아 있는 것이 있는지 먼저 확인
  let stuCount = 0;
  const stuSheet = getSheet(SHEET.학생목록);
  if (stuSheet) {
    const d = stuSheet.getDataRange().getValues();
    for (let i = 1; i < d.length; i++) if (sameClass(d[i][0], name) && d[i][3]) stuCount++;
  }
  let asgCount = 0;
  const asgSheet = getSheet(SHEET.과제목록);
  if (asgSheet) {
    const d = asgSheet.getDataRange().getValues();
    for (let i = 1; i < d.length; i++) if (d[i][0] && sameClass(d[i][5], name)) asgCount++;
  }
  const ss = getSS();
  const subSh = ss.getSheetByName(name + " 제출물");
  const subCount = subSh ? Math.max(0, subSh.getLastRow() - 1) : 0;

  if (stuCount || asgCount || subCount) {
    const parts = [];
    if (stuCount)  parts.push("학생 " + stuCount + "명");
    if (asgCount)  parts.push("이 클래스 전용 과제 " + asgCount + "개");
    if (subCount)  parts.push("제출물 " + subCount + "건");
    return {
      success: false,
      message: name + " 클래스에 " + parts.join(", ") + "이(가) 남아 있어 삭제할 수 없습니다. 먼저 정리한 뒤 다시 시도해주세요.",
      blocked: true
    };
  }

  // 비어 있으므로 안전하게 삭제
  sheet.deleteRow(rowIdx);
  [" 제출물", " 피드백"].forEach(function (suffix) {
    const sh = ss.getSheetByName(name + suffix);
    if (sh && sh.getLastRow() <= 1) ss.deleteSheet(sh);   // 헤더만 있는 빈 시트만 정리
  });

  // 이 반의 학급공약도 함께 정리 (학생·제출물이 없는 반이므로 남겨 둘 이유가 없다)
  const pldSh = getSheet(SHEET.학급공약);
  if (pldSh && pldSh.getLastRow() >= 2) {
    const d = pldSh.getDataRange().getValues();
    for (let i = d.length - 1; i >= 1; i--) {
      if (String(d[i][1]).trim() === name) pldSh.deleteRow(i + 1);
    }
  }

  return { success: true, message: "클래스가 삭제되었습니다." };
}


// ══════════════════════════════════════════════════
// ██ 도장(참 잘했어요) · 학급공약 ██
// ══════════════════════════════════════════════════
//
// 도장은 피드백 시트 G열에 함께 저장된다(별도 시트 없음).
// 차감은 '학급공약' 시트의 완료 행으로만 일어난다.
//
//   학생 개인 누계 = 그 학생 피드백 행들의 도장 합계  (공약을 실시해도 줄지 않음)
//   학급 적립      = 그 반 학생들의 도장 합계
//   학급 잔여      = 학급 적립 − 실시 완료된 공약들의 목표치 합계
//
// 개인 누계를 깎지 않는 이유: 공약은 반 전체가 함께 쓰는 것이라
// 열심히 한 학생의 기록까지 사라지면 안 되기 때문이다.

// ── 학급공약 읽기 ─────────────────────────────────
// 시트 열: A=공약ID, B=클래스, C=공약내용, D=목표도장, E=상태, F=생성일시, G=실시일시
function readPledges(className) {
  const cls = String(className == null ? "" : className).trim();
  if (!cls) return [];
  const sh = getSheet(SHEET.학급공약);
  if (!sh) return [];
  const data = sh.getDataRange().getValues();
  const out = [];
  for (let i = 1; i < data.length; i++) {
    if (!data[i][0]) continue;
    if (!sameClass(data[i][1], cls)) continue;
    out.push({
      id:          String(data[i][0]),
      class_name:  String(data[i][1]),
      content:     String(data[i][2] == null ? "" : data[i][2]),
      goal:        Math.max(0, parseInt(data[i][3], 10) || 0),
      status:      String(data[i][4] || "진행중"),
      created_at:  asTimeText(data[i][5]),
      executed_at: asTimeText(data[i][6])
    });
  }
  return out;
}

// ── 도장 집계 ─────────────────────────────────────
// 이미 읽어 둔 피드백 데이터(fbData)를 그대로 받아서 계산한다.
// 그래서 이 함수 때문에 늘어나는 시트 왕복은 학급공약 시트 1회뿐이다.
//   idx          : buildStudentIndex() 결과
//   fbData       : 피드백 시트 전체 값
//   className    : 집계할 반 (비면 반 집계는 건너뛴다)
//   who          : 개인 누계를 뽑을 학생 (없으면 건너뛴다)
//   withStudents : true면 반 학생별 누계 목록도 만든다
function summarizeStamps(idx, fbData, className, who, withStudents) {
  const cls = String(className == null ? "" : className).trim();
  let earned = 0, mine = 0;
  const perStudent = {};

  for (let i = 1; i < fbData.length; i++) {
    if (!fbData[i][0]) continue;
    const n = parseStamp(fbData[i][6]);
    if (!n) continue;
    if (who && ownsRow(who, fbData[i][1], fbData[i][2])) mine += n;
    if (!cls) continue;
    // 학생목록에 없는 행은 어느 반인지 알 수 없으므로 반 집계에서 뺀다
    const stu = studentOfRow(idx, fbData[i][1], fbData[i][2]);
    if (!stu || !sameClass(stu.class, cls)) continue;
    earned += n;
    perStudent[stu.canon] = (perStudent[stu.canon] || 0) + n;
  }

  const pledges = readPledges(cls);
  let redeemed = 0;
  pledges.forEach(function(p) { if (p.status === "완료") redeemed += p.goal; });

  const result = {
    my_stamps: mine,
    earned:    earned,
    redeemed:  redeemed,
    available: earned - redeemed,
    pledges:   pledges
  };

  if (withStudents) {
    result.students = idx.list
      .filter(function(s) { return sameClass(s.class, cls); })
      .map(function(s) {
        return {
          code:   s.code,
          number: s.number,
          name:   s.name,
          class:  s.class,
          stamps: perStudent[s.canon] || 0
        };
      })
      .sort(function(a, b) { return String(a.number).localeCompare(String(b.number)); });
  }
  return result;
}

// ── 도장 현황판 (교사) ────────────────────────────
function getStampBoard(password, class_name) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  const cls = String(class_name == null ? "" : class_name).trim();
  if (!cls) return { success: false, message: "클래스를 먼저 선택해주세요." };

  const idx     = buildStudentIndex();
  const fbSheet = getSheet(SHEET.피드백);
  const fbData  = fbSheet ? fbSheet.getDataRange().getValues() : [];

  const b = summarizeStamps(idx, fbData, cls, null, true);
  return {
    success:    true,
    class_name: cls,
    earned:     b.earned,
    redeemed:   b.redeemed,
    available:  b.available,
    students:   b.students,
    pledges:    b.pledges
  };
}

// ── 학급공약 추가 (교사) ──────────────────────────
function addPledge(password, class_name, content, goal) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  const cls = String(class_name == null ? "" : class_name).trim();
  if (!cls) return { success: false, message: "클래스를 먼저 선택해주세요." };
  const text = String(content == null ? "" : content).trim();
  if (!text) return { success: false, message: "공약 내용을 입력해주세요." };
  const target = parseInt(goal, 10);
  if (isNaN(target) || target < 1) return { success: false, message: "목표 도장 개수를 1개 이상으로 입력해주세요." };
  if (target > 100000) return { success: false, message: "목표 도장 개수가 너무 큽니다." };

  initPledgeSheet();
  const sh = getSheet(SHEET.학급공약);
  if (!sh) return { success: false, message: "시트 초기화 오류입니다." };

  // ★ 밀리초 타임스탬프만 쓰면 공약을 연달아 등록할 때 ID가 겹친다.
  //   ID가 겹치면 '실시' 버튼이 엉뚱한 공약을 집어 든다. UUID를 덧붙여 막는다.
  const id  = "PLG_" + new Date().getTime() + "_" + Utilities.getUuid().slice(0, 8);
  const row = sh.getLastRow() + 1;
  const range = sh.getRange(row, 1, 1, 7);
  range.setNumberFormat("@");   // 클래스명("3-1")이 날짜로 바뀌는 것 방지
  range.setValues([[id, cls, text, target, "진행중", now(), ""]]);
  // 목표 개수는 숫자로 다뤄야 하므로 그 칸만 서식을 되돌린다
  sh.getRange(row, 4).setNumberFormat("0").setValue(target);

  return { success: true, message: "학급공약이 등록되었습니다.", id: id };
}

// ── 학급공약 삭제 (교사) ──────────────────────────
function deletePledge(password, pledge_id) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  if (!pledge_id) return { success: false, message: "공약을 찾을 수 없습니다." };

  const sh = getSheet(SHEET.학급공약);
  if (!sh) return { success: false, message: "시트 초기화 오류입니다." };

  const lock = LockService.getScriptLock();
  try { lock.waitLock(10000); }
  catch(e) { return { success: false, message: "다른 작업이 진행 중입니다. 잠시 후 다시 시도해주세요." }; }

  try {
    const data = sh.getDataRange().getValues();
    for (let i = 1; i < data.length; i++) {
      if (String(data[i][0]) !== String(pledge_id)) continue;
      const wasDone = String(data[i][4]) === "완료";
      const goal    = parseInt(data[i][3], 10) || 0;
      sh.deleteRow(i + 1);
      return {
        success: true,
        // 완료된 공약을 지우면 그때 깎았던 도장이 다시 잔여로 돌아온다
        message: wasDone
          ? "실시 완료된 공약을 삭제했습니다. 차감했던 도장 " + goal + "개가 잔여로 복구되었습니다."
          : "학급공약이 삭제되었습니다."
      };
    }
    return { success: false, message: "공약을 찾을 수 없습니다." };
  } finally {
    lock.releaseLock();
  }
}

// ── 공약 실시 (교사) — 도장 차감 ──────────────────
// 버튼이 두 번 눌리면 목표치가 두 번 깎이므로, 반드시 잠근 뒤에
// 잔여 도장을 다시 세어 확인한다.
function executePledge(password, pledge_id) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  if (!pledge_id) return { success: false, message: "공약을 찾을 수 없습니다." };

  const lock = LockService.getScriptLock();
  try { lock.waitLock(15000); }
  catch(e) { return { success: false, message: "다른 작업이 진행 중입니다. 잠시 후 다시 시도해주세요." }; }

  try {
    const sh = getSheet(SHEET.학급공약);
    if (!sh) return { success: false, message: "시트 초기화 오류입니다." };

    // ★ 잠근 뒤에 다시 읽는다. 화면에 떠 있던 값이 아니라 지금 시트의 값으로 판단해야
    //   버튼이 두 번 눌렸을 때 도장이 두 번 깎이는 것을 막을 수 있다.
    const data = sh.getDataRange().getValues();
    let row = -1, cls = "", goal = 0, content = "", created = "";
    for (let i = 1; i < data.length; i++) {
      if (String(data[i][0]) !== String(pledge_id)) continue;
      if (String(data[i][4]) === "완료") {
        return { success: false, message: "이미 실시한 공약입니다." };
      }
      row     = i + 1;
      cls     = String(data[i][1]).trim();
      content = String(data[i][2] == null ? "" : data[i][2]);
      goal    = Math.max(0, parseInt(data[i][3], 10) || 0);
      created = data[i][5];
      break;
    }
    if (row < 0)  return { success: false, message: "공약을 찾을 수 없습니다." };
    if (goal < 1) return { success: false, message: "목표 도장 개수가 올바르지 않습니다." };

    // 지금 시점의 잔여 도장을 다시 계산
    const idx     = buildStudentIndex();
    const fbSheet = getSheet(SHEET.피드백);
    const fbData  = fbSheet ? fbSheet.getDataRange().getValues() : [];
    const b = summarizeStamps(idx, fbData, cls, null, false);

    if (b.available < goal) {
      return {
        success: false,
        message: "아직 목표에 도달하지 않았습니다. (잔여 " + b.available + "개 / 목표 " + goal + "개)"
      };
    }

    const executedAt = now();
    // 상태·생성일시·실시일시를 한 번에 쓴다 (E~G열)
    sh.getRange(row, 5, 1, 3).setValues([["완료", created, executedAt]]);

    const left = b.available - goal;
    return {
      success:   true,
      message:   "🎉 공약을 실시했습니다! 도장 " + goal + "개가 차감되어 잔여 " + left + "개입니다.",
      content:   content,
      goal:      goal,
      available: left
    };
  } finally {
    lock.releaseLock();
  }
}


// ══════════════════════════════════════════════════
// ██ 워드클라우드 함수들 ██
// ══════════════════════════════════════════════════

const WC_SHEET = "워드클라우드";

// ── 워드클라우드 시트 초기화 ──
function initWcSheet() {
  const ss = getSS();
  if (!ss.getSheetByName(WC_SHEET)) {
    const sh = ss.insertSheet(WC_SHEET);
    // 열: A=세션ID, B=질문, C=1인당횟수, D=활성여부, E=생성일시, F=응답JSON
    sh.appendRow(["세션ID", "질문", "1인당횟수", "활성여부", "생성일시", "응답JSON"]);
    const hdr = sh.getRange(1, 1, 1, 6);
    hdr.setBackground("#c8974a");
    hdr.setFontColor("#ffffff");
    hdr.setFontWeight("bold");
    sh.setFrozenRows(1);
    sh.setColumnWidth(1, 160);
    sh.setColumnWidth(2, 300);
    sh.setColumnWidth(3, 100);
    sh.setColumnWidth(4, 100);
    sh.setColumnWidth(5, 160);
    sh.setColumnWidth(6, 600);
  }
}

// ── 세션 생성 (교사) ──
function wcCreateSession(password, question, maxPerPerson) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  if (!question) return { success: false, message: "질문을 입력해주세요." };

  initWcSheet();
  const ss = getSS();
  const sh = ss.getSheetByName(WC_SHEET);

  // 기존 활성 세션 모두 종료
  const data = sh.getDataRange().getValues();
  for (let i = 1; i < data.length; i++) {
    if (String(data[i][3]) === "활성") {
      sh.getRange(i + 1, 4).setValue("종료");
    }
  }

  const sessionId = "WC" + new Date().getTime();
  const maxN = parseInt(maxPerPerson) || 5;
  sh.appendRow([
    sessionId,
    question,
    maxN,
    "활성",
    now(),
    JSON.stringify({ responses: [], participants: {} })
  ]);

  return { success: true, sessionId, question, maxPerPerson: maxN };
}

// ── 세션 조회 (학생/교사 공용 — 인증 불필요) ──
function wcGetSession(sessionId) {
  if (!sessionId) return { success: false, message: "세션ID가 없습니다." };
  initWcSheet();
  const ss = getSS();
  const sh = ss.getSheetByName(WC_SHEET);
  if (!sh) return { success: false, message: "시트 없음" };

  const data = sh.getDataRange().getValues();
  for (let i = 1; i < data.length; i++) {
    if (String(data[i][0]) === String(sessionId)) {
      let parsed = { responses: [], participants: {} };
      try { parsed = JSON.parse(data[i][5] || "{}"); } catch(e) {}
      return {
        success: true,
        sessionId:    data[i][0],
        question:     data[i][1],
        maxPerPerson: parseInt(data[i][2]) || 5,
        active:       String(data[i][3]) === "활성",
        responses:    parsed.responses    || [],
        participants: parsed.participants || {}
      };
    }
  }
  return { success: false, message: "세션을 찾을 수 없습니다." };
}

// ── 단어 제출 (학생) ──
function wcSubmitWord(sessionId, word, studentId) {
  if (!sessionId || !word || !studentId)
    return { success: false, message: "필수 항목 누락" };

  word = String(word).trim().slice(0, 20);
  if (!word) return { success: false, message: "단어를 입력해주세요." };

  initWcSheet();

  // ★ 한 셀의 JSON을 읽고-고치고-쓰기 때문에, 여러 학생이 동시에 제출하면
  //   나중 쓰기가 앞의 쓰기를 덮어써 단어가 조용히 사라졌다.
  //   잠금을 걸어 한 번에 한 명씩만 갱신하도록 한다.
  const lock = LockService.getScriptLock();
  try {
    lock.waitLock(20000);
  } catch(e) {
    return { success: false, message: "지금 접속이 몰리고 있습니다. 잠시 후 다시 눌러주세요." };
  }

  try {
    const ss = getSS();
    const sh = ss.getSheetByName(WC_SHEET);
    if (!sh) return { success: false, message: "시트 없음" };

    const data = sh.getDataRange().getValues();
    for (let i = 1; i < data.length; i++) {
      if (String(data[i][0]) !== String(sessionId)) continue;
      if (String(data[i][3]) !== "활성") return { success: false, message: "세션이 종료되었습니다." };

      const maxN = parseInt(data[i][2]) || 5;
      let parsed = { responses: [], participants: {} };
      try { parsed = JSON.parse(data[i][5] || "{}"); } catch(e) {}

      const currentCount = (parsed.participants || {})[studentId] || 0;
      if (currentCount >= maxN) return { success: false, message: "제출 횟수를 초과했습니다.", remaining: 0 };

      parsed.responses  = parsed.responses  || [];
      parsed.participants = parsed.participants || {};
      parsed.responses.push({ word, studentId, time: new Date().getTime() });
      parsed.participants[studentId] = currentCount + 1;

      sh.getRange(i + 1, 6).setValue(JSON.stringify(parsed));
      SpreadsheetApp.flush();   // 잠금을 풀기 전에 확실히 기록

      const remaining = maxN - (currentCount + 1);
      return { success: true, remaining, total: maxN };
    }
    return { success: false, message: "세션을 찾을 수 없습니다." };
  } finally {
    lock.releaseLock();
  }
}

// ── 응답 목록 조회 (교사 폴링용) ──
function wcGetResponses(sessionId) {
  if (!sessionId) return { success: false, message: "세션ID 없음" };
  const result = wcGetSession(sessionId);
  if (!result.success) return result;
  return {
    success:          true,
    active:           result.active,
    responses:        result.responses    || [],
    participants:     result.participants || {},
    responseCount:    (result.responses || []).length,
    participantCount: Object.keys(result.participants || {}).length
  };
}

// ── 세션 종료 (교사) ──
function wcStopSessionGas(password, sessionId) {
  if (password !== getTeacherPassword()) return { success: false, message: "권한 없음" };
  initWcSheet();
  const ss = getSS();
  const sh = ss.getSheetByName(WC_SHEET);
  if (!sh) return { success: false, message: "시트 없음" };

  const data = sh.getDataRange().getValues();
  for (let i = 1; i < data.length; i++) {
    if (String(data[i][0]) === String(sessionId)) {
      sh.getRange(i + 1, 4).setValue("종료");
      return { success: true };
    }
  }
  return { success: false, message: "세션을 찾을 수 없습니다." };
}

index.html

Apps Script 왼쪽 목록에는 index 라는 이름으로 보입니다. 그 파일에 붙여넣으세요.

코드 미리보기

<!DOCTYPE html>
<html lang="ko">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Done? Done!</title>
<link href="https://fonts.googleapis.com/css2?family=Nanum+Gothic:wght@400;700;800&family=Nanum+Pen+Script&display=swap" rel="stylesheet">
<style>
:root {
  --bg: #f5f5f0;
  --surface: #ffffff;
  --border: #e8e8e4;
  --text: #2d2d2d;
  --text2: #6b6b6b;
  --text3: #aaaaaa;
  --accent: #4a90d9;
  --accent2: #e8734a;
  --submitted: #b8e4c4;
  --submitted-bg: #e8f7ed;
  --submitted-text: #2d7a47;
  --notsubmit: #f4b8b8;
  --notsubmit-bg: #fde8e8;
  --notsubmit-text: #c0392b;
  --rejected: #f9e0b0;
  --rejected-bg: #fdf5e6;
  --rejected-text: #b07d2a;
  --shadow: 0 2px 8px rgba(0,0,0,0.08);
  --shadow-md: 0 4px 16px rgba(0,0,0,0.12);
  --r: 14px;
  --r-sm: 8px;
  --wc-bg: #faf8f4;
  --wc-accent: #c8974a;
  --wc-surface: #ffffff;
  --wc-border: #e8dfc8;
}
[data-theme="봄"]    { --bg:#fff5f7;--surface:#fff;--border:#ffd6e7;--text:#2d1a20;--text2:#9b4060;--text3:#d4a0b5;--accent:#e8608a;--accent2:#c44477;--wc-bg:#fff0f5;--wc-accent:#e8608a;--wc-border:#ffd6e7; }
[data-theme="여름"]  { --bg:#f0faff;--surface:#fff;--border:#bae6fd;--text:#0c1a2e;--text2:#1e6baa;--text3:#7ec0e8;--accent:#0284c7;--accent2:#0891b2;--wc-bg:#e8f7ff;--wc-accent:#0284c7;--wc-border:#bae6fd; }
[data-theme="가을"]  { --bg:#fff8f0;--surface:#fff;--border:#fed7aa;--text:#2d1500;--text2:#92400e;--text3:#d4aa7a;--accent:#ea580c;--accent2:#b45309;--wc-bg:#fff4e8;--wc-accent:#ea580c;--wc-border:#fed7aa; }
[data-theme="겨울"]  { --bg:#f0f4f9;--surface:#fff;--border:#cbd5e1;--text:#0f172a;--text2:#475569;--text3:#94a3b8;--accent:#3b82f6;--accent2:#6366f1;--wc-bg:#e8edf8;--wc-accent:#3b82f6;--wc-border:#cbd5e1; }
[data-theme="파스텔"] { --bg:#fdf4ff;--surface:#fff;--border:#e9d5ff;--text:#1e0b2e;--text2:#7c3aed;--text3:#c4b5fd;--accent:#9333ea;--accent2:#a855f7;--wc-bg:#f5e8ff;--wc-accent:#9333ea;--wc-border:#e9d5ff; }
[data-theme="파스텔-핑크"]  { --bg:#fff0f6;--surface:#fff;--border:#fbc8db;--text:#2d0a1a;--text2:#be185d;--text3:#f9a8d4;--accent:#ec4899;--accent2:#db2777;--wc-bg:#ffe8f4;--wc-accent:#ec4899;--wc-border:#fbc8db; }
[data-theme="파스텔-민트"]  { --bg:#f0fdf9;--surface:#fff;--border:#99f6e4;--text:#0a2420;--text2:#0f766e;--text3:#5eead4;--accent:#14b8a6;--accent2:#0d9488;--wc-bg:#e4fdf8;--wc-accent:#14b8a6;--wc-border:#99f6e4; }
[data-theme="파스텔-스카이"] { --bg:#f0f9ff;--surface:#fff;--border:#bae6fd;--text:#0c1f2e;--text2:#0369a1;--text3:#7dd3fc;--accent:#0ea5e9;--accent2:#0284c7;--wc-bg:#e0f5ff;--wc-accent:#0ea5e9;--wc-border:#bae6fd; }
[data-theme="파스텔-레몬"]  { --bg:#fefce8;--surface:#fff;--border:#fde68a;--text:#2a2000;--text2:#92400e;--text3:#fcd34d;--accent:#f59e0b;--accent2:#d97706;--wc-bg:#fefacc;--wc-accent:#f59e0b;--wc-border:#fde68a; }
[data-theme="파스텔-라벤더"] { --bg:#f5f3ff;--surface:#fff;--border:#ddd6fe;--text:#1e1040;--text2:#5b21b6;--text3:#a78bfa;--accent:#7c3aed;--accent2:#6d28d9;--wc-bg:#ede8ff;--wc-accent:#7c3aed;--wc-border:#ddd6fe; }

[data-theme="봄"]    #page-login { background: linear-gradient(145deg,#fff0f5,#ffe4f0); }
[data-theme="여름"]  #page-login { background: linear-gradient(145deg,#f0faff,#dbeafe); }
[data-theme="가을"]  #page-login { background: linear-gradient(145deg,#fff8f0,#ffedd5); }
[data-theme="겨울"]  #page-login { background: linear-gradient(145deg,#f0f4f9,#dbeafe); }
[data-theme="파스텔"] #page-login { background: linear-gradient(145deg,#fdf4ff,#ede9fe); }
[data-theme="파스텔-핑크"]  #page-login { background: linear-gradient(145deg,#fff0f6,#fce7f3); }
[data-theme="파스텔-민트"]  #page-login { background: linear-gradient(145deg,#f0fdf9,#ccfbf1); }
[data-theme="파스텔-스카이"] #page-login { background: linear-gradient(145deg,#f0f9ff,#e0f2fe); }
[data-theme="파스텔-레몬"]  #page-login { background: linear-gradient(145deg,#fefce8,#fef9c3); }
[data-theme="파스텔-라벤더"] #page-login { background: linear-gradient(145deg,#f5f3ff,#ede9fe); }

* { box-sizing: border-box; margin: 0; padding: 0; }
body {
  font-family: 'Nanum Gothic', sans-serif;
  background: var(--bg);
  color: var(--text);
  min-height: 100vh;
  font-size: 14px;
  line-height: 1.6;
}
.hidden { display: none !important; }

/* ── 로딩 / 토스트 ── */
.loading-overlay {
  position: fixed; inset: 0;
  background: rgba(245,245,240,0.88);
  display: flex; align-items: center; justify-content: center;
  z-index: 9999; flex-direction: column; gap: 14px;
}
.spinner { width: 38px; height: 38px; border: 3px solid var(--border); border-top-color: var(--accent); border-radius: 50%; animation: spin 0.7s linear infinite; }
@keyframes spin { to { transform: rotate(360deg); } }
.loading-overlay p { color: var(--text2); font-size: 14px; font-weight: 700; }
.toast { position: fixed; bottom: 28px; left: 50%; transform: translateX(-50%) translateY(80px); background: #2d2d2d; color: #fff; padding: 12px 24px; border-radius: 30px; font-size: 14px; font-weight: 700; z-index: 9998; transition: transform 0.3s cubic-bezier(.34,1.56,.64,1); white-space: nowrap; pointer-events: none; }
.toast.show { transform: translateX(-50%) translateY(0); }

.page { display: none; min-height: 100vh; }
.page.active { display: block; }

/* ══ 로그인 ══ */
#page-login { display: flex; align-items: center; justify-content: center; min-height: 100vh; background: linear-gradient(145deg, #fef9f0 0%, #e8f4fd 100%); }
.login-wrap { width: 100%; max-width: 400px; padding: 20px; animation: fadeUp 0.4s ease; }
@keyframes fadeUp { from { opacity: 0; transform: translateY(20px); } to { opacity: 1; transform: translateY(0); } }
.login-logo { text-align: center; margin-bottom: 28px; }
.login-logo-icon { font-size: 52px; margin-bottom: 10px; filter: drop-shadow(0 4px 12px rgba(0,0,0,0.1)); }
.login-logo h1 { font-family: 'Nanum Pen Script', cursive; font-size: 46px; color: var(--text); letter-spacing: -0.5px; line-height: 1.1; }
.login-logo-sub { font-family: 'Nanum Pen Script', cursive; font-size: 21px; color: var(--text2); margin-top: 2px; line-height: 1.2; }
.login-teacher-name { font-size: 13px; color: var(--accent); font-weight: 800; background: rgba(74,144,217,0.09); padding: 4px 14px; border-radius: 20px; display: inline-block; margin-top: 6px; }
.login-logo p { font-size: 13px; color: var(--text2); margin-top: 8px; font-weight: 700; }
.insta-link { color: var(--accent); font-weight: 800; text-decoration: none; display: inline-flex; align-items: center; gap: 5px; vertical-align: middle; }
.insta-link:hover { text-decoration: underline; }
.insta-link svg { flex: none; }
.login-box { background: var(--surface); border-radius: var(--r); padding: 28px 24px; box-shadow: var(--shadow-md); margin-bottom: 12px; border: 1.5px solid var(--border); }
.login-box .form-group { margin-bottom: 12px; }
.login-box input { width: 100%; padding: 12px 14px; border: 1.5px solid var(--border); border-radius: var(--r-sm); font-family: 'Nanum Gothic', sans-serif; font-size: 14px; color: var(--text); background: var(--bg); outline: none; transition: border-color 0.15s; }
.login-box input:focus { border-color: var(--accent); }
.login-divider { display: flex; align-items: center; gap: 10px; margin: 18px 0; color: var(--text3); font-size: 12px; font-weight: 700; }
.login-divider::before, .login-divider::after { content: ''; flex: 1; height: 1px; background: var(--border); }
/* ★ 자동 로그인 체크박스.
   .login-box input 규칙이 width:100%를 씌우기 때문에 여기서 되돌려준다. */
.login-remember { display: flex; align-items: center; gap: 8px; margin: -2px 0 14px; cursor: pointer; user-select: none; }
.login-remember input[type="checkbox"] { width: 18px; height: 18px; flex: none; padding: 0; margin: 0; accent-color: var(--accent); cursor: pointer; }
.login-remember span { font-size: 12.5px; font-weight: 700; color: var(--text2); line-height: 1.4; }
.btn-grad { width: 100%; padding: 13px; background: linear-gradient(135deg, #4a90d9, #357abd); color: #fff; border: none; border-radius: var(--r-sm); font-family: 'Nanum Gothic', sans-serif; font-size: 15px; font-weight: 800; cursor: pointer; transition: all 0.15s; box-shadow: 0 3px 12px rgba(74,144,217,0.4); }
.btn-grad:hover { transform: translateY(-1px); box-shadow: 0 5px 18px rgba(74,144,217,0.5); }
.btn-teacher { width: 100%; padding: 12px; background: var(--surface); color: var(--text2); border: 1.5px solid var(--border); border-radius: var(--r-sm); font-family: 'Nanum Gothic', sans-serif; font-size: 14px; font-weight: 700; cursor: pointer; transition: all 0.15s; }
.btn-teacher:hover { border-color: var(--text2); color: var(--text); background: var(--bg); }
.login-footer { text-align: center; font-size: 11px; color: var(--text3); line-height: 1.9; margin-top: 16px; }

/* ══ 학생 화면 ══ */
#page-student { background: var(--bg); }
.s-nav { background: var(--surface); border-bottom: 1.5px solid var(--border); padding: 0 24px; height: 56px; display: flex; align-items: center; justify-content: space-between; position: sticky; top: 0; z-index: 100; box-shadow: 0 2px 8px rgba(0,0,0,0.05); }
.nav-brand { display: flex; flex-direction: column; justify-content: center; gap: 0; line-height: 1; }
.nav-brand-main { font-family: 'Nanum Pen Script', cursive; font-size: 26px; color: var(--text); line-height: 1.1; }
.nav-brand-sub { font-size: 11px; color: var(--text3); font-weight: 700; line-height: 1; }
.nav-user-info { display: flex; align-items: center; gap: 10px; font-size: 13px; color: var(--text2); }
.nav-avatar { width: 34px; height: 34px; border-radius: 50%; background: linear-gradient(135deg, var(--accent), #357abd); display: flex; align-items: center; justify-content: center; font-size: 15px; font-weight: 800; color: #fff; }
.btn-logout { background: none; border: 1.5px solid var(--border); color: var(--text3); padding: 5px 12px; border-radius: 20px; font-size: 12px; font-weight: 700; cursor: pointer; transition: all 0.15s; font-family: 'Nanum Gothic', sans-serif; }
.btn-logout:hover { border-color: var(--text2); color: var(--text); }
.s-tabs { background: var(--surface); border-bottom: 1.5px solid var(--border); display: flex; }
.tab-btn { background: none; border: none; color: var(--text3); padding: 14px 24px; font-family: 'Nanum Gothic', sans-serif; font-size: 13px; font-weight: 700; border-bottom: 2.5px solid transparent; margin-bottom: -1.5px; cursor: pointer; transition: all 0.15s; flex: 1; text-align: center; }
.tab-btn.active { color: var(--accent); border-bottom-color: var(--accent); }
.tab-btn:hover:not(.active) { color: var(--text2); }
.s-container { max-width: 880px; margin: 0 auto; padding: 24px 16px; }

.assignment-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(190px, 1fr)); gap: 12px; margin-bottom: 24px; }
.a-pill { background: var(--surface); border-radius: var(--r); padding: 16px; border: 1.5px solid var(--border); cursor: pointer; transition: all 0.18s; position: relative; overflow: hidden; }
.a-pill:hover { transform: translateY(-2px); box-shadow: var(--shadow-md); }
.a-pill.submitted { background: var(--submitted-bg); border-color: var(--submitted); }
.a-pill.not-submitted { background: var(--notsubmit-bg); border-color: var(--notsubmit); }
.a-pill.rejected { background: var(--rejected-bg); border-color: var(--rejected); }
.a-pill.selected { box-shadow: 0 0 0 3px rgba(74,144,217,0.3); border-color: var(--accent); }
.ap-sticker { font-size: 22px; margin-bottom: 8px; display: block; }
.ap-num { font-size: 11px; font-weight: 700; color: var(--text3); margin-bottom: 5px; }
.ap-title { font-size: 13px; font-weight: 800; color: var(--text); line-height: 1.4; }
.ap-status-text { font-size: 11px; margin-top: 8px; font-weight: 700; padding: 3px 8px; border-radius: 20px; display: inline-block; }
.status-submitted { background: var(--submitted); color: var(--submitted-text); }
.status-notsubmit { background: var(--notsubmit); color: var(--notsubmit-text); }
.status-rejected { background: var(--rejected); color: var(--rejected-text); }

.submit-form { background: var(--surface); border-radius: var(--r); padding: 22px; border: 1.5px solid var(--border); box-shadow: var(--shadow); }
.submit-form h3 { font-size: 16px; font-weight: 800; margin-bottom: 16px; }
.form-group { margin-bottom: 14px; }
.form-group label { font-size: 12px; font-weight: 800; color: var(--text2); display: block; margin-bottom: 6px; text-transform: uppercase; letter-spacing: 0.5px; }
.form-group input, .form-group textarea, .form-group select { width: 100%; padding: 11px 13px; border: 1.5px solid var(--border); border-radius: var(--r-sm); font-family: 'Nanum Gothic', sans-serif; font-size: 14px; color: var(--text); background: var(--bg); outline: none; transition: border-color 0.15s; }
.form-group input:focus, .form-group textarea:focus, .form-group select:focus { border-color: var(--accent); }
.form-group textarea { min-height: 100px; resize: vertical; line-height: 1.7; }
.form-row { display: flex; gap: 10px; }
.form-row .form-group { flex: 1; }
.form-actions { display: flex; justify-content: flex-end; gap: 8px; margin-top: 12px; }
.btn-primary { background: var(--accent); color: #fff; padding: 9px 20px; border-radius: var(--r-sm); font-family: 'Nanum Gothic', sans-serif; font-size: 14px; font-weight: 800; border: none; cursor: pointer; transition: all 0.15s; }
.btn-primary:hover { background: #357abd; transform: translateY(-1px); }
.btn-outline { background: transparent; color: var(--text2); padding: 9px 20px; border-radius: var(--r-sm); font-family: 'Nanum Gothic', sans-serif; font-size: 14px; font-weight: 700; border: 1.5px solid var(--border); cursor: pointer; transition: all 0.15s; }
.btn-outline:hover { border-color: var(--text2); color: var(--text); }
.btn-sm { padding: 6px 14px; font-size: 13px; }
.btn-red { background: #e74c3c; color: #fff; padding: 9px 16px; border-radius: var(--r-sm); font-family: 'Nanum Gothic', sans-serif; font-size: 13px; font-weight: 800; border: none; cursor: pointer; transition: all 0.15s; }
.btn-red:hover { background: #c0392b; }

.feedback-box { background: #fffbf0; border: 1.5px solid #f0c060; border-radius: var(--r-sm); padding: 14px 16px; margin-top: 12px; }
.feedback-box.rejected-box { background: var(--notsubmit-bg); border-color: var(--notsubmit); }
.fb-label { font-size: 12px; font-weight: 800; color: #8a6000; margin-bottom: 6px; }
.fb-label.rejected-label { color: var(--notsubmit-text); }
.fb-content { font-size: 14px; color: #6a4800; white-space: pre-wrap; line-height: 1.7; }
.fb-content.rejected-content { color: var(--notsubmit-text); }
.no-feedback { font-size: 13px; color: var(--text3); margin-top: 10px; }

/* ── 과제 안내(설명) 표시 ── */
.assign-desc-box { background: #eaf2fb; border: 1.5px solid #b8d4f0; border-radius: var(--r-sm); padding: 14px 16px; margin-bottom: 10px; }
.assign-desc-label { font-size: 12px; font-weight: 800; color: #1a5a99; margin-bottom: 6px; text-transform: uppercase; letter-spacing: .5px; }
.assign-desc-body { font-size: 14px; color: #1c3d5c; white-space: pre-wrap; line-height: 1.75; }
.assign-due { display: inline-block; font-size: 12px; font-weight: 800; color: var(--rejected-text); background: var(--rejected-bg); border: 1.5px solid var(--rejected); padding: 4px 12px; border-radius: 20px; margin-bottom: 10px; }
.av-label { font-size: 12px; font-weight: 800; color: var(--text2); text-transform: uppercase; letter-spacing: .5px; margin: 16px 0 6px; }
.av-mine { background: var(--bg); border: 1.5px solid var(--border); border-radius: var(--r-sm); padding: 12px 14px; font-size: 14px; white-space: pre-wrap; line-height: 1.7; color: var(--text2); }
.av-date { font-size: 12px; color: var(--text3); font-weight: 700; margin-top: 6px; }
/* 과제 타일에 '안내 있음' 표시 */
.ap-hasinfo { font-size: 10px; font-weight: 800; color: #1a5a99; background: #eaf2fb; padding: 2px 7px; border-radius: 10px; margin-top: 6px; display: inline-block; }

.card { background: var(--surface); border-radius: var(--r); padding: 18px 20px; box-shadow: var(--shadow); margin-bottom: 12px; border: 1.5px solid var(--border); transition: box-shadow 0.15s; }
.card:hover { box-shadow: var(--shadow-md); }
.card-title { font-size: 15px; font-weight: 800; }
.card-meta { font-size: 12px; color: var(--text3); margin-top: 3px; }
.card-body { font-size: 14px; color: var(--text2); white-space: pre-wrap; line-height: 1.7; margin-top: 10px; }
.card-header { display: flex; align-items: flex-start; justify-content: space-between; gap: 10px; }
.chip { display: inline-flex; align-items: center; gap: 4px; font-size: 11px; font-weight: 800; padding: 3px 10px; border-radius: 20px; }
.chip-green { background: var(--submitted); color: var(--submitted-text); }
.chip-red { background: var(--notsubmit); color: var(--notsubmit-text); }
.chip-orange { background: var(--rejected); color: var(--rejected-text); }
.chip-blue { background: #d0e8fa; color: #1a5a99; }
.chip-gray { background: #f0f0ee; color: #888; }
.section-header { display: flex; align-items: center; justify-content: space-between; margin-bottom: 16px; }
.section-header h2 { font-size: 16px; font-weight: 800; }
.empty-state { text-align: center; padding: 50px 20px; color: var(--text3); }
.empty-state .icon { font-size: 42px; margin-bottom: 12px; }
.empty-state p { font-size: 14px; font-weight: 700; }

.file-drop-zone { border: 2px dashed var(--border); border-radius: var(--r-sm); padding: 20px; text-align: center; cursor: pointer; transition: all 0.2s; background: var(--bg); position: relative; }
.file-drop-zone:hover, .file-drop-zone.dragover { border-color: var(--accent); background: rgba(74,144,217,0.04); }
.file-drop-zone input[type="file"] { position: absolute; inset: 0; opacity: 0; cursor: pointer; width: 100%; height: 100%; }
.file-drop-icon { font-size: 26px; margin-bottom: 6px; }
.file-drop-text { font-size: 13px; color: var(--text2); font-weight: 700; }
.file-drop-hint { font-size: 11px; color: var(--text3); margin-top: 4px; }
.file-preview-wrap { margin-top: 12px; border: 1.5px solid var(--border); border-radius: var(--r-sm); overflow: hidden; background: #000; }
.file-preview-wrap img { width: 100%; max-height: 300px; object-fit: contain; display: block; background: #f0f0f0; }
.file-preview-wrap iframe { width: 100%; height: 300px; border: none; display: block; }
.file-info-bar { display: flex; align-items: center; justify-content: space-between; padding: 8px 12px; background: var(--surface); border-top: 1.5px solid var(--border); font-size: 12px; color: var(--text2); gap: 8px; }
.file-info-bar .file-name { font-weight: 800; color: var(--text); flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.btn-remove-file { background: none; color: #e74c3c; font-size: 12px; padding: 3px 8px; border: 1px solid #e74c3c; border-radius: 4px; cursor: pointer; flex-shrink: 0; font-family: 'Nanum Gothic', sans-serif; }
.btn-remove-file:hover { background: #e74c3c; color: #fff; }
.file-attach-view { margin-top: 10px; border: 1.5px solid var(--border); border-radius: var(--r-sm); overflow: hidden; }
.file-attach-view img { width: 100%; max-height: 260px; object-fit: contain; display: block; background: #f0f0f0; }
.file-attach-view iframe { width: 100%; height: 260px; border: none; display: block; }
.file-attach-header { display: flex; align-items: center; justify-content: space-between; padding: 8px 12px; background: var(--bg); border-bottom: 1.5px solid var(--border); font-size: 12px; }
.file-attach-header a { color: var(--accent); font-weight: 800; text-decoration: none; }
.upload-progress { margin-top: 8px; font-size: 12px; color: var(--accent); display: flex; align-items: center; gap: 6px; font-weight: 700; }
.mini-spinner { width: 14px; height: 14px; border: 2px solid #d0e8fa; border-top-color: var(--accent); border-radius: 50%; animation: spin 0.7s linear infinite; flex-shrink: 0; }

/* ══ 교사 화면 ══ */
#page-teacher { background: var(--bg); display: none; }
#page-teacher.active { display: flex; }

/* ── 사이드바 ── */
.t-sidebar { width: 260px; min-height: 100vh; background: var(--surface); border-right: 1.5px solid var(--border); display: flex; flex-direction: column; padding: 0; position: sticky; top: 0; height: 100vh; overflow-y: auto; flex-shrink: 0; transition: transform 0.3s ease; }
/* 사이드바 스크롤바 — 기본 회색 막대 대신 평소엔 숨고 마우스를 올리면 스르륵 나타나는 얇은 막대 */
.t-sidebar { scroll-behavior: smooth; overscroll-behavior: contain; scrollbar-width: thin; scrollbar-color: transparent transparent; transition: transform 0.3s ease, scrollbar-color 0.25s ease; }
.t-sidebar:hover { scrollbar-color: var(--text3) transparent; }
.t-sidebar::-webkit-scrollbar { width: 10px; }
.t-sidebar::-webkit-scrollbar-track { background: transparent; }
.t-sidebar::-webkit-scrollbar-thumb { background-color: transparent; border: 3px solid transparent; background-clip: content-box; border-radius: 20px; transition: background-color 0.25s ease; }
.t-sidebar:hover::-webkit-scrollbar-thumb { background-color: var(--border); }
.t-sidebar::-webkit-scrollbar-thumb:hover { background-color: var(--text3); }
.t-sidebar-brand { padding: 18px 20px 12px; border-bottom: 1.5px solid var(--border); }
.t-sidebar-brand .brand-logo { font-family: 'Nanum Pen Script', cursive; font-size: 26px; color: var(--text); display: block; line-height: 1.1; }
.t-sidebar-brand .brand-sub-ko { font-family: 'Nanum Pen Script', cursive; font-size: 15px; color: var(--text2); display: block; line-height: 1.2; }
.t-sidebar-brand .brand-sub { font-size: 11px; color: var(--text3); font-weight: 700; margin-top: 2px; display: block; }
.t-sidebar-class { padding: 14px 20px; border-bottom: 1.5px solid var(--border); }
.t-sidebar-class .class-label { font-size: 11px; font-weight: 800; color: var(--text3); margin-bottom: 8px; text-transform: uppercase; letter-spacing: 0.5px; }
.class-chip { display: flex; align-items: center; padding: 8px 12px; border-radius: var(--r-sm); cursor: pointer; transition: all 0.15s; font-size: 13px; font-weight: 700; color: var(--text2); margin-bottom: 4px; gap: 8px; }
.class-chip:hover { background: var(--bg); color: var(--text); }
.class-chip.active { background: var(--accent); color: #fff; }
.class-chip .cc-dot { width: 10px; height: 10px; border-radius: 50%; background: currentColor; opacity: 0.5; flex-shrink: 0; }
.class-chip.active .cc-dot { opacity: 1; background: #fff; }
.class-chip .cc-name { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
/* 터치 기기에는 hover가 없으므로 평소에도 알아볼 만큼은 보이게 둔다 */
.class-chip .cc-actions { display: flex; gap: 1px; flex-shrink: 0; opacity: 0.7; transition: opacity 0.15s; }
.class-chip:hover .cc-actions { opacity: 1; }
.class-chip.active .cc-actions { opacity: 0.85; }
.cc-btn { background: none; border: none; padding: 2px 4px; border-radius: 4px; font-size: 11px; line-height: 1; cursor: pointer; color: inherit; }
.cc-btn:hover { background: rgba(0,0,0,0.12); }
.class-chip.active .cc-btn:hover { background: rgba(255,255,255,0.28); }
.btn-add-class { width: 100%; margin-top: 6px; padding: 7px 12px; border-radius: var(--r-sm); border: 1.5px dashed var(--border); background: none; font-family: 'Nanum Gothic', sans-serif; font-size: 12px; font-weight: 800; color: var(--text3); cursor: pointer; transition: all 0.15s; text-align: center; }
.btn-add-class:hover { border-color: var(--accent); color: var(--accent); background: rgba(74,144,217,0.05); }
.entered-class-banner { padding: 8px 14px; margin: 6px 10px; background: var(--accent); color: #fff; border-radius: var(--r-sm); font-size: 12px; font-weight: 800; display: flex; align-items: center; justify-content: space-between; }
.btn-exit-class { background: none; border: none; color: rgba(255,255,255,0.8); font-size: 11px; cursor: pointer; font-family: 'Nanum Gothic', sans-serif; font-weight: 700; padding: 0; }
.btn-exit-class:hover { color: #fff; }
.t-sidebar-menu { padding: 12px 10px; flex: 1; }
.t-sidebar-menu.hidden { display: none; }
.menu-item { display: flex; align-items: center; gap: 10px; padding: 10px 12px; border-radius: var(--r-sm); cursor: pointer; transition: all 0.15s; font-size: 13px; font-weight: 700; color: var(--text2); margin-bottom: 2px; border: none; background: none; width: 100%; text-align: left; font-family: 'Nanum Gothic', sans-serif; }
.menu-item:hover { background: var(--bg); color: var(--text); }
.menu-item.active { background: #eaf2fb; color: var(--accent); }
.menu-icon { font-size: 16px; width: 22px; text-align: center; flex-shrink: 0; }

/* ── 워드클라우드 사이드바 섹션 ── */
.wc-sidebar-section {
  border-top: 1.5px solid var(--border);
  padding: 14px 10px 10px;
  background: var(--wc-bg, #faf8f4);
}
.wc-sidebar-label {
  font-size: 11px; font-weight: 800; color: var(--wc-accent, #c8974a);
  text-transform: uppercase; letter-spacing: 0.5px;
  padding: 0 2px; margin-bottom: 8px;
  display: flex; align-items: center; gap: 6px;
}
.wc-sidebar-label .wc-live-dot {
  width: 7px; height: 7px; border-radius: 50%;
  background: #e74c3c; animation: pulse-dot 1.2s ease-in-out infinite;
  display: none;
}
.wc-sidebar-label .wc-live-dot.on { display: inline-block; }
@keyframes pulse-dot { 0%,100%{opacity:1;transform:scale(1)} 50%{opacity:.5;transform:scale(1.3)} }
.wc-menu-btn {
  display: flex; align-items: center; gap: 10px;
  padding: 10px 12px; border-radius: var(--r-sm);
  cursor: pointer; font-size: 13px; font-weight: 800;
  border: none; background: none; width: 100%; text-align: left;
  font-family: 'Nanum Gothic', sans-serif;
  color: var(--wc-accent, #c8974a);
  border: 1.5px solid var(--wc-border, #e8dfc8);
  transition: all 0.15s;
}
.wc-menu-btn:hover { background: var(--wc-border, #e8dfc8); }
.wc-menu-btn.active { background: var(--wc-accent, #c8974a); color: #fff; border-color: transparent; }

.t-sidebar-footer { padding: 14px 14px; border-top: 1.5px solid var(--border); }
.t-sidebar-footer .btn-logout { width: 100%; text-align: center; display: block; }

/* ── 모바일 사이드바 토글 ── */
.sidebar-toggle { display: none; }
.sidebar-overlay { display: none; position: fixed; inset: 0; background: rgba(0,0,0,0.4); z-index: 199; }

/* 교사 메인 영역 */
.t-main { flex: 1; min-width: 0; display: flex; flex-direction: column; max-height: 100vh; overflow-y: auto; }
.t-topbar { background: var(--surface); border-bottom: 1.5px solid var(--border); padding: 0 28px; height: 56px; display: flex; align-items: center; justify-content: space-between; position: sticky; top: 0; z-index: 50; box-shadow: 0 2px 8px rgba(0,0,0,0.04); }
.t-topbar-title { font-size: 18px; font-weight: 800; }
.t-topbar-actions { display: flex; gap: 8px; align-items: center; }

.t-panel { display: none; padding: 24px 28px; }
.t-panel.active { display: block; }

/* 교사 학생카드 그리드 */
.class-overview-header { margin-bottom: 20px; display: flex; align-items: center; gap: 16px; }
.class-overview-header h2 { font-size: 20px; font-weight: 800; }
.overview-stats { display: flex; gap: 8px; }
.stat-badge { padding: 4px 12px; border-radius: 20px; font-size: 12px; font-weight: 800; }
.student-card-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(140px, 1fr)); gap: 10px; }
.student-card { background: var(--surface); border-radius: var(--r); padding: 14px; border: 1.5px solid var(--border); cursor: pointer; transition: all 0.18s; text-align: center; position: relative; }
.student-card:hover { transform: translateY(-2px); box-shadow: var(--shadow-md); }
.student-card.submitted { background: var(--submitted-bg); border-color: var(--submitted); }
.student-card.not-submitted { background: var(--notsubmit-bg); border-color: var(--notsubmit); }
.sc-sticker { font-size: 24px; display: block; margin-bottom: 6px; }
.sc-name { font-size: 13px; font-weight: 800; color: var(--text); }
.sc-number { font-size: 11px; color: var(--text3); margin-top: 2px; font-weight: 700; }
.sc-count { font-size: 11px; font-weight: 800; margin-top: 6px; padding: 2px 8px; border-radius: 12px; display: inline-block; }
.sc-count.done { background: var(--submitted); color: var(--submitted-text); }
.sc-count.none { background: var(--notsubmit); color: var(--notsubmit-text); }

.student-detail-header { display: flex; align-items: center; gap: 14px; margin-bottom: 20px; flex-wrap: wrap; }
.student-detail-header h2 { font-size: 18px; font-weight: 800; }
.back-btn { background: none; border: 1.5px solid var(--border); border-radius: var(--r-sm); padding: 7px 14px; font-family: 'Nanum Gothic', sans-serif; font-size: 13px; font-weight: 700; color: var(--text2); cursor: pointer; transition: all 0.15s; display: flex; align-items: center; gap: 6px; }
.back-btn:hover { border-color: var(--text2); color: var(--text); }
.excel-btn { background: var(--accent); border: none; border-radius: var(--r-sm); padding: 7px 14px; font-family: 'Nanum Gothic', sans-serif; font-size: 13px; font-weight: 800; color: #fff; cursor: pointer; transition: all 0.15s; display: flex; align-items: center; gap: 6px; margin-left: auto; }
.excel-btn:hover { transform: translateY(-1px); box-shadow: var(--shadow-md); filter: brightness(1.05); }

.assignment-card-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(175px, 1fr)); gap: 12px; }
.assignment-card { background: var(--surface); border-radius: var(--r); padding: 16px; border: 1.5px solid var(--border); cursor: pointer; transition: all 0.18s; position: relative; }
.assignment-card:hover { transform: translateY(-2px); box-shadow: var(--shadow-md); }
.assignment-card.has-new { background: var(--notsubmit-bg); border-color: var(--notsubmit); }
.ac-icon { font-size: 22px; margin-bottom: 8px; display: block; }
.ac-title { font-size: 13px; font-weight: 800; color: var(--text); line-height: 1.4; }
.ac-meta { font-size: 11px; color: var(--text3); margin-top: 6px; font-weight: 700; }
.ac-badge { position: absolute; top: 10px; right: 10px; font-size: 10px; font-weight: 800; padding: 2px 7px; border-radius: 10px; }
.ac-badge.red { background: var(--notsubmit); color: var(--notsubmit-text); }
.ac-badge.green { background: var(--submitted); color: var(--submitted-text); }

.assignment-detail-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(155px, 1fr)); gap: 10px; }
.submission-card { background: var(--surface); border-radius: var(--r); padding: 14px; border: 1.5px solid var(--border); cursor: pointer; transition: all 0.18s; text-align: center; }
.submission-card:hover { transform: translateY(-2px); box-shadow: var(--shadow-md); }
.submission-card.submitted { background: var(--submitted-bg); border-color: var(--submitted); }
.submission-card.not-submitted { background: var(--notsubmit-bg); border-color: var(--notsubmit); }
.sc2-sticker { font-size: 24px; margin-bottom: 6px; display: block; }
.sc2-name { font-size: 13px; font-weight: 800; }
.sc2-status { font-size: 11px; font-weight: 800; margin-top: 6px; padding: 2px 8px; border-radius: 12px; display: inline-block; }
.sc2-date { font-size: 10px; color: var(--text3); margin-top: 4px; font-weight: 700; }

/* 매트릭스 */
.matrix-wrap { overflow-x: auto; }
.matrix-table { border-collapse: collapse; font-size: 12px; min-width: 100%; }
.matrix-table th, .matrix-table td { border: 1px solid var(--border); padding: 7px 10px; white-space: nowrap; }
.matrix-table thead th { background: var(--bg); font-weight: 800; color: var(--text2); font-size: 11px; text-transform: uppercase; letter-spacing: 0.3px; cursor: pointer; user-select: none; position: sticky; top: 0; z-index: 2; }
.matrix-table thead th:hover { background: #ececea; }
.matrix-table tbody td:first-child { font-weight: 800; background: var(--bg); position: sticky; left: 0; z-index: 1; }
.matrix-cell { width: 36px; text-align: center; cursor: pointer; border-radius: 4px; font-size: 16px; transition: transform 0.1s; }
.matrix-cell:hover { transform: scale(1.3); }
.assign-compact-grid { display: flex; flex-wrap: wrap; gap: 8px; margin-top: 12px; }
.assign-compact-item { background: var(--surface); border: 1.5px solid var(--border); border-radius: var(--r-sm); padding: 8px 14px; font-size: 13px; font-weight: 700; color: var(--text); display: flex; align-items: center; gap: 8px; }
.assign-compact-item .ac-meta-inline { font-size: 11px; color: var(--text3); }
.assign-list-row { background: var(--surface); border: 1.5px solid var(--border); border-radius: var(--r-sm); padding: 12px 16px; display: flex; align-items: center; gap: 12px; margin-bottom: 8px; }
.assign-list-row:hover { border-color: var(--accent); }
.assign-list-row .alr-info { flex: 1; min-width: 0; }
.assign-list-row .alr-title { font-size: 14px; font-weight: 800; color: var(--text); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
.assign-list-row .alr-meta { font-size: 11px; color: var(--text3); margin-top: 2px; }
.assign-list-row .alr-actions { display: flex; gap: 6px; flex-shrink: 0; }
.btn-edit-assign { background: var(--accent); color: #fff; border: none; border-radius: 6px; padding: 5px 12px; font-size: 12px; font-weight: 700; cursor: pointer; }
.btn-edit-assign:hover { opacity: 0.85; }
.btn-del-assign { background: #ef4444; color: #fff; border: none; border-radius: 6px; padding: 5px 12px; font-size: 12px; font-weight: 700; cursor: pointer; }
.btn-del-assign:hover { opacity: 0.85; }
/* 수정 모달 */
#modal-edit-assign { display:none; position:fixed; inset:0; background:rgba(0,0,0,0.45); z-index:9000; align-items:center; justify-content:center; }
#modal-edit-assign.open { display:flex; }
#modal-edit-assign .modal-box { background:var(--surface); border-radius:var(--r); padding:28px 24px; width:min(520px,94vw); max-height:90vh; overflow-y:auto; box-shadow:var(--shadow-md); }
#modal-edit-assign h3 { margin:0 0 18px; font-size:17px; }
.modal-sm { background: var(--surface); border-radius: var(--r); width: 100%; max-width: 360px; padding: 24px; box-shadow: 0 20px 60px rgba(0,0,0,0.25); animation: modalIn 0.22s cubic-bezier(.34,1.56,.64,1); }

.modal-overlay { position: fixed; inset: 0; background: rgba(0,0,0,0.4); display: flex; align-items: center; justify-content: center; z-index: 9000; padding: 20px; }
.modal { background: var(--surface); border-radius: var(--r); width: 100%; max-width: 560px; max-height: 90vh; overflow-y: auto; box-shadow: 0 20px 60px rgba(0,0,0,0.25); animation: modalIn 0.22s cubic-bezier(.34,1.56,.64,1); }
@keyframes modalIn { from { opacity: 0; transform: scale(0.94); } to { opacity: 1; transform: scale(1); } }
.modal-header { padding: 20px 24px 14px; border-bottom: 1.5px solid var(--border); display: flex; align-items: center; justify-content: space-between; }
.modal-header h3 { font-size: 16px; font-weight: 800; }
.modal-close { background: none; border: none; font-size: 20px; cursor: pointer; color: var(--text3); padding: 2px 6px; border-radius: 6px; transition: all 0.15s; }
.modal-close:hover { background: var(--bg); color: var(--text); }
.modal-body { padding: 20px 24px; }
.modal-content-text { background: var(--bg); border-radius: var(--r-sm); padding: 14px; font-size: 14px; color: var(--text); line-height: 1.7; white-space: pre-wrap; margin-bottom: 16px; border: 1.5px solid var(--border); }
.modal-footer { padding: 14px 24px 20px; border-top: 1.5px solid var(--border); display: flex; gap: 8px; justify-content: flex-end; }
.sticker-selector { margin-bottom: 16px; }
.sticker-selector-label { font-size: 12px; font-weight: 800; color: var(--text2); text-transform: uppercase; letter-spacing: 0.5px; margin-bottom: 8px; }
.sticker-options { display: flex; gap: 8px; flex-wrap: wrap; }
.sticker-opt { font-size: 28px; cursor: pointer; padding: 6px 10px; border-radius: var(--r-sm); border: 2px solid transparent; transition: all 0.15s; }
.sticker-opt:hover { background: var(--bg); transform: scale(1.1); }
.sticker-opt.selected { border-color: var(--accent); background: #eaf2fb; }

/* ── 도장(참 잘했어요) · 학급공약 ── */
.stamp-options { display: flex; gap: 8px; flex-wrap: wrap; }
.stamp-opt { display: inline-flex; align-items: center; gap: 5px; font-size: 13px; font-weight: 800; cursor: pointer; padding: 7px 13px; border-radius: var(--r-sm); border: 2px solid var(--border); background: var(--surface); color: var(--text2); transition: all 0.15s; user-select: none; }
.stamp-opt:hover { border-color: var(--accent2); transform: translateY(-1px); }
.stamp-opt.selected { border-color: var(--accent2); background: #fdf0ea; color: var(--accent2); }
.stamp-hint { font-size: 11px; font-weight: 700; color: var(--text3); margin-top: 7px; line-height: 1.5; }

/* 학생 화면 상단 도장 요약 */
.stamp-hero { display: flex; flex-wrap: wrap; gap: 16px; align-items: center; background: var(--surface); border: 1.5px solid var(--border); border-radius: var(--r); padding: 16px 20px; margin-bottom: 16px; box-shadow: var(--shadow); }
.stamp-hero-mine { display: flex; flex-direction: column; align-items: center; justify-content: center; min-width: 92px; padding-right: 18px; border-right: 1.5px solid var(--border); }
.stamp-hero-label { font-size: 11px; font-weight: 800; color: var(--text3); letter-spacing: 0.5px; }
.stamp-hero-num { font-size: 30px; font-weight: 800; color: var(--accent2); line-height: 1.25; }
.stamp-hero-body { flex: 1; min-width: 220px; }
.stamp-hero-title { font-size: 13px; font-weight: 800; color: var(--text); margin-bottom: 8px; display: flex; justify-content: space-between; gap: 8px; flex-wrap: wrap; }
.stamp-hero-note { font-size: 12px; font-weight: 700; color: var(--text3); margin-top: 7px; line-height: 1.5; }
.stamp-bar { height: 12px; border-radius: 20px; background: var(--bg); border: 1.5px solid var(--border); overflow: hidden; }
.stamp-bar-fill { height: 100%; background: linear-gradient(90deg, #f3a683, var(--accent2)); border-radius: 20px; transition: width 0.4s; }
.stamp-bar-fill.done { background: linear-gradient(90deg, #8fd6a4, #2d7a47); }

/* 교사 도장 현황판 */
.stamp-stats { display: flex; gap: 12px; flex-wrap: wrap; margin-bottom: 18px; }
.stamp-stat { flex: 1; min-width: 132px; background: var(--surface); border: 1.5px solid var(--border); border-radius: var(--r); padding: 14px 18px; box-shadow: var(--shadow); }
.stamp-stat-label { font-size: 11px; font-weight: 800; color: var(--text3); letter-spacing: 0.5px; }
.stamp-stat-num { font-size: 26px; font-weight: 800; line-height: 1.35; }
.stamp-stat-unit { font-size: 14px; font-weight: 800; margin-left: 2px; }
.stamp-rank { flex: 1.5; min-width: 190px; }
.stamp-rank-list { display: flex; flex-direction: column; gap: 2px; margin-top: 7px; }
.stamp-rank-row { display: flex; align-items: center; gap: 7px; font-size: 13px; font-weight: 800; color: var(--text); line-height: 1.5; }
.srk-medal { font-size: 14px; flex-shrink: 0; }
.srk-name { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.srk-num { flex-shrink: 0; color: var(--accent2); }
.stamp-rank-empty { font-size: 12px; font-weight: 700; color: var(--text3); margin-top: 10px; }
.stamp-sub { font-size: 13px; font-weight: 800; color: var(--text2); margin: 20px 0 10px; }
.pledge-form { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; }
.pledge-form input { padding: 10px 13px; border: 1.5px solid var(--border); border-radius: var(--r-sm); font-family: 'Nanum Gothic', sans-serif; font-size: 14px; color: var(--text); background: var(--bg); outline: none; transition: border-color 0.15s; }
.pledge-form input:focus { border-color: var(--accent2); }
.pledge-input-text { flex: 1; min-width: 200px; }
.pledge-input-goal { width: 132px; }
.pledge-card { background: var(--surface); border: 1.5px solid var(--border); border-radius: var(--r); padding: 16px 18px; margin-bottom: 10px; box-shadow: var(--shadow); }
.pledge-card.ready { border-color: var(--accent2); }
.pledge-card.done { background: var(--submitted-bg); border-color: var(--submitted); }
.pledge-head { display: flex; align-items: flex-start; justify-content: space-between; gap: 10px; margin-bottom: 10px; flex-wrap: wrap; }
.pledge-text { font-size: 14px; font-weight: 800; color: var(--text); line-height: 1.5; flex: 1; min-width: 180px; }
.pledge-actions { display: flex; gap: 6px; flex-shrink: 0; }
.pledge-meta { font-size: 12px; font-weight: 700; color: var(--text3); margin-top: 8px; line-height: 1.5; }
.stamp-student-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(118px, 1fr)); gap: 10px; }
.stamp-student { background: var(--surface); border: 1.5px solid var(--border); border-radius: var(--r-sm); padding: 12px 10px; text-align: center; }
.stamp-student.zero { opacity: 0.5; }
.stamp-student-name { font-size: 13px; font-weight: 800; color: var(--text); }
.stamp-student-num { font-size: 11px; font-weight: 700; color: var(--text3); margin-bottom: 6px; }
.stamp-student-count { font-size: 16px; font-weight: 800; color: var(--accent2); }

.student-table-wrap { overflow-x: auto; }
table { width: 100%; border-collapse: collapse; font-size: 14px; }
th { text-align: left; padding: 10px 14px; background: var(--bg); color: var(--text2); font-size: 12px; font-weight: 800; border-bottom: 1.5px solid var(--border); cursor: pointer; user-select: none; text-transform: uppercase; letter-spacing: 0.5px; }
th:hover { background: #ececea; }
td { padding: 12px 14px; border-bottom: 1.5px solid var(--border); }
tr:last-child td { border-bottom: none; }
tr:hover td { background: var(--bg); }
.code-badge { font-family: monospace; font-size: 13px; font-weight: 800; color: var(--accent); background: #eaf2fb; padding: 3px 10px; border-radius: 6px; letter-spacing: 2px; }

.filter-bar { background: var(--surface); border-radius: var(--r); padding: 16px 18px; margin-bottom: 18px; border: 1.5px solid var(--border); display: flex; gap: 10px; flex-wrap: wrap; align-items: flex-end; box-shadow: var(--shadow); }
.filter-bar .form-group { flex: 1; min-width: 110px; margin: 0; }
.sub-card { background: var(--surface); border-radius: var(--r); padding: 18px 20px; border: 1.5px solid var(--border); box-shadow: var(--shadow); margin-bottom: 12px; }
.sub-card-header { display: flex; align-items: center; justify-content: space-between; margin-bottom: 10px; }
.sub-student { font-weight: 800; font-size: 15px; }
.sub-meta { font-size: 12px; color: var(--text3); margin-top: 2px; font-weight: 700; }
.sub-content { font-size: 14px; color: var(--text2); white-space: pre-wrap; line-height: 1.7; background: var(--bg); padding: 12px; border-radius: var(--r-sm); margin-bottom: 12px; border: 1.5px solid var(--border); }
.feedback-saved { background: var(--submitted-bg); border: 1.5px solid var(--submitted); border-radius: var(--r-sm); padding: 12px 14px; font-size: 14px; color: var(--submitted-text); white-space: pre-wrap; margin-bottom: 10px; line-height: 1.7; }
.sub-action-bar { display: flex; gap: 8px; justify-content: flex-end; margin-top: 8px; }

/* ══════════════════════════════════════
   워드클라우드 패널
══════════════════════════════════════ */
#panel-wordcloud {
  padding: 0;
  display: none;
}
#panel-wordcloud.active { display: block; }

.wc-layout {
  display: grid;
  grid-template-columns: 1fr 1fr;
  gap: 0;
  min-height: calc(100vh - 56px);
}

/* 왼쪽: 설정 패널 */
.wc-setup-pane {
  padding: 28px 28px;
  border-right: 1.5px solid var(--wc-border, #e8dfc8);
  background: var(--wc-bg, #faf8f4);
  display: flex;
  flex-direction: column;
  gap: 0;
  overflow-y: auto;
  max-height: calc(100vh - 56px);
}
.wc-steps {
  display: flex; align-items: center; gap: 8px;
  margin-bottom: 24px; font-size: 12px; font-weight: 800; color: var(--text3);
}
.wc-step { padding: 4px 12px; border-radius: 20px; background: var(--border); color: var(--text3); cursor: default; }
.wc-step.active { background: var(--wc-accent, #c8974a); color: #fff; }
.wc-step.done { background: #b8e4c4; color: #2d7a47; }
.wc-steps .step-arrow { color: var(--text3); font-size: 10px; }

.wc-section-label {
  font-size: 11px; font-weight: 800; color: var(--text3);
  text-transform: uppercase; letter-spacing: 0.5px;
  margin-bottom: 8px; margin-top: 6px;
}
.wc-question-input {
  width: 100%; padding: 14px 16px;
  border: 2px solid var(--wc-border, #e8dfc8);
  border-radius: var(--r);
  font-family: 'Nanum Gothic', sans-serif;
  font-size: 15px; font-weight: 800;
  color: var(--text); background: var(--surface);
  outline: none; transition: border-color 0.2s;
  resize: none; line-height: 1.6;
}
.wc-question-input:focus { border-color: var(--wc-accent, #c8974a); }
.wc-question-input::placeholder { color: var(--text3); font-weight: 400; }

.wc-preset-chips {
  display: flex; flex-wrap: wrap; gap: 7px; margin-bottom: 16px;
}
.wc-preset-chip {
  padding: 6px 13px; border-radius: 20px;
  border: 1.5px solid var(--wc-border, #e8dfc8);
  background: var(--surface); color: var(--text2);
  font-size: 12px; font-weight: 700; cursor: pointer;
  transition: all 0.15s; font-family: 'Nanum Gothic', sans-serif;
}
.wc-preset-chip:hover { border-color: var(--wc-accent, #c8974a); color: var(--wc-accent, #c8974a); background: var(--wc-bg, #faf8f4); }
.wc-preset-actions { display: flex; gap: 8px; margin-bottom: 16px; }
.wc-btn-sm { padding: 6px 14px; border-radius: var(--r-sm); border: 1.5px solid var(--wc-border, #e8dfc8); background: var(--surface); color: var(--text2); font-size: 12px; font-weight: 800; cursor: pointer; font-family: 'Nanum Gothic', sans-serif; transition: all 0.15s; display: flex; align-items: center; gap: 5px; }
.wc-btn-sm:hover { border-color: var(--wc-accent, #c8974a); color: var(--wc-accent, #c8974a); }

.wc-count-row {
  display: flex; align-items: center; gap: 12px; margin-bottom: 18px;
}
.wc-count-label { font-size: 13px; font-weight: 800; color: var(--text2); }
.wc-count-ctrl { display: flex; align-items: center; gap: 0; }
.wc-count-btn { width: 34px; height: 34px; border: 1.5px solid var(--wc-border, #e8dfc8); background: var(--surface); color: var(--text2); font-size: 18px; font-weight: 800; cursor: pointer; transition: all 0.15s; border-radius: 0; font-family: 'Nanum Gothic', sans-serif; }
.wc-count-btn:first-child { border-radius: var(--r-sm) 0 0 var(--r-sm); }
.wc-count-btn:last-child { border-radius: 0 var(--r-sm) var(--r-sm) 0; }
.wc-count-btn:hover { background: var(--wc-border, #e8dfc8); }
.wc-count-display { min-width: 44px; text-align: center; font-size: 16px; font-weight: 800; padding: 0 8px; border-top: 1.5px solid var(--wc-border, #e8dfc8); border-bottom: 1.5px solid var(--wc-border, #e8dfc8); height: 34px; line-height: 30px; background: var(--bg); color: var(--text); }

.wc-session-link {
  font-size: 12px; color: var(--text2); font-weight: 700;
  display: flex; align-items: center; gap: 6px;
  margin-bottom: 14px; cursor: pointer;
  padding: 6px 10px; border-radius: var(--r-sm);
  background: var(--surface); border: 1.5px solid var(--wc-border, #e8dfc8);
  transition: all 0.15s;
}
.wc-session-link:hover { background: var(--bg); }

.wc-start-btn {
  width: 100%; padding: 16px;
  background: linear-gradient(135deg, var(--wc-accent, #c8974a), #a87030);
  color: #fff; border: none; border-radius: var(--r);
  font-family: 'Nanum Pen Script', cursive;
  font-size: 26px; letter-spacing: 0.5px;
  cursor: pointer; transition: all 0.2s;
  box-shadow: 0 4px 16px rgba(200,151,74,0.35);
  display: flex; align-items: center; justify-content: center; gap: 10px;
}
.wc-start-btn:hover { transform: translateY(-2px); box-shadow: 0 8px 24px rgba(200,151,74,0.45); }
.wc-start-btn:disabled { opacity: 0.5; cursor: not-allowed; transform: none; }

.wc-stop-btn {
  width: 100%; padding: 12px;
  background: #e74c3c; color: #fff;
  border: none; border-radius: var(--r);
  font-family: 'Nanum Gothic', sans-serif;
  font-size: 14px; font-weight: 800;
  cursor: pointer; transition: all 0.15s;
  margin-top: 10px;
}
.wc-stop-btn:hover { background: #c0392b; }

/* 오른쪽: 라이브 패널 */
.wc-live-pane {
  padding: 28px;
  background: var(--surface);
  display: flex; flex-direction: column;
  overflow-y: auto;
  max-height: calc(100vh - 56px);
}
.wc-live-header {
  display: flex; align-items: center; justify-content: space-between;
  margin-bottom: 20px;
}
.wc-live-question {
  font-size: 18px; font-weight: 800;
  color: var(--text); line-height: 1.4;
  background: var(--wc-bg, #faf8f4);
  border: 1.5px solid var(--wc-border, #e8dfc8);
  border-radius: var(--r); padding: 14px 18px;
  margin-bottom: 18px;
}
.wc-live-question .wc-q-label { font-size: 11px; font-weight: 800; color: var(--wc-accent, #c8974a); text-transform: uppercase; letter-spacing: 0.5px; margin-bottom: 6px; display: block; }
.wc-live-question .wc-q-text { font-size: 16px; color: var(--text); font-weight: 800; }

.wc-qr-area {
  display: flex; gap: 16px; margin-bottom: 20px;
  align-items: flex-start;
}
.wc-qr-box {
  position: relative;
  border: 2px solid var(--wc-border, #e8dfc8);
  border-radius: var(--r); padding: 12px;
  background: #fff; flex-shrink: 0;
  box-shadow: var(--shadow);
  display: flex; flex-direction: column; align-items: center; gap: 8px;
}
.wc-qr-box canvas { display: block; }
.wc-qr-url {
  font-size: 10px; color: var(--text3); word-break: break-all;
  text-align: center; max-width: 140px; line-height: 1.5;
}
.wc-qr-shorten-status {
  font-size: 10px; color: var(--wc-accent, #c8974a);
  text-align: center; min-height: 13px;
}
.wc-qr-full-btn {
  position: absolute; top: 6px; right: 6px;
  width: 24px; height: 24px; padding: 0;
  border-radius: 6px; border: 1.5px solid var(--wc-border, #e8dfc8);
  background: var(--surface); color: var(--text2);
  font-size: 13px; line-height: 1; cursor: pointer;
  display: flex; align-items: center; justify-content: center;
  transition: all 0.15s;
}
.wc-qr-full-btn:hover { border-color: var(--wc-accent, #c8974a); color: var(--wc-accent, #c8974a); }

/* 전체화면 — QR만 화면 전체에 크게 */
.wc-qr-box:fullscreen {
  width: 100vw; height: 100vh;
  border: none; border-radius: 0; box-shadow: none;
  justify-content: center; gap: 24px;
}
.wc-qr-box:fullscreen canvas {
  width: min(80vw, 80vh); height: min(80vw, 80vh);
}
.wc-qr-box:fullscreen .wc-qr-url { font-size: 22px; max-width: 80vw; }
.wc-qr-box:fullscreen .wc-qr-shorten-status { display: none; }
.wc-qr-box:fullscreen .wc-qr-full-btn { top: 20px; right: 20px; width: 36px; height: 36px; font-size: 18px; }
.wc-stats-box {
  flex: 1; display: flex; flex-direction: column; gap: 8px;
}
.wc-stat-item {
  background: var(--wc-bg, #faf8f4); border: 1.5px solid var(--wc-border, #e8dfc8);
  border-radius: var(--r-sm); padding: 10px 14px;
  display: flex; justify-content: space-between; align-items: center;
}
.wc-stat-label { font-size: 12px; font-weight: 800; color: var(--text2); }
.wc-stat-val { font-size: 20px; font-weight: 800; color: var(--wc-accent, #c8974a); }

.wc-canvas-wrap {
  border-radius: var(--r); overflow: hidden;
  border: 1.5px solid var(--wc-border, #e8dfc8);
  background: #fff;
  margin-bottom: 16px;
  box-shadow: var(--shadow);
  flex-shrink: 0;
}
.wc-canvas-wrap canvas { display: block; width: 100%; }

/* 답변 목록 */
.wc-responses-list {
  display: flex; flex-wrap: wrap; gap: 8px;
  padding: 14px;
  background: var(--wc-bg, #faf8f4);
  border: 1.5px solid var(--wc-border, #e8dfc8);
  border-radius: var(--r);
  max-height: 200px; overflow-y: auto;
}
.wc-response-chip {
  padding: 5px 13px; border-radius: 20px;
  font-size: 12px; font-weight: 800;
  animation: popIn 0.3s cubic-bezier(.34,1.56,.64,1);
}
@keyframes popIn { from{opacity:0;transform:scale(0.7)} to{opacity:1;transform:scale(1)} }

/* ══ 워드클라우드 학생 응답 페이지 ══ */
#page-wc-student {
  display: none;
  min-height: 100vh;
  background: var(--wc-bg, #faf8f4);
  flex-direction: column;
  align-items: center;
  justify-content: center;
}
#page-wc-student.active {
  display: flex;
}
.wc-student-wrap {
  width: 100%; max-width: 480px; padding: 24px 20px;
}
.wc-student-header {
  text-align: center; margin-bottom: 28px;
}
.wc-student-header .wc-app-name {
  font-family: 'Nanum Pen Script', cursive;
  font-size: 36px; color: var(--text);
  line-height: 1.1; margin-bottom: 4px;
}
.wc-student-header .wc-app-sub {
  font-size: 13px; color: var(--text3); font-weight: 700;
}
.wc-student-question-box {
  background: var(--surface); border: 2px solid var(--wc-border, #e8dfc8);
  border-radius: var(--r); padding: 18px 20px; margin-bottom: 20px;
  box-shadow: var(--shadow);
}
.wc-student-question-box .q-label {
  font-size: 11px; font-weight: 800; color: var(--wc-accent, #c8974a);
  text-transform: uppercase; letter-spacing: 0.5px; margin-bottom: 8px;
}
.wc-student-question-box .q-text {
  font-size: 17px; font-weight: 800; color: var(--text); line-height: 1.5;
}
.wc-student-answer-box {
  background: var(--surface); border: 1.5px solid var(--wc-border, #e8dfc8);
  border-radius: var(--r); padding: 20px; box-shadow: var(--shadow);
}
.wc-student-input {
  width: 100%; padding: 13px 16px;
  border: 2px solid var(--wc-border, #e8dfc8);
  border-radius: var(--r-sm); background: var(--bg);
  font-family: 'Nanum Gothic', sans-serif;
  font-size: 15px; color: var(--text);
  outline: none; transition: border-color 0.15s;
  margin-bottom: 12px;
}
.wc-student-input:focus { border-color: var(--wc-accent, #c8974a); }
.wc-student-submit-btn {
  width: 100%; padding: 14px;
  background: linear-gradient(135deg, var(--wc-accent, #c8974a), #a87030);
  color: #fff; border: none; border-radius: var(--r-sm);
  font-family: 'Nanum Gothic', sans-serif;
  font-size: 15px; font-weight: 800;
  cursor: pointer; transition: all 0.15s;
  box-shadow: 0 3px 12px rgba(200,151,74,0.4);
}
.wc-student-submit-btn:hover { transform: translateY(-1px); }
.wc-student-submit-btn:disabled { opacity: 0.5; cursor: not-allowed; transform: none; }
.wc-remain-count {
  text-align: center; margin-top: 12px;
  font-size: 13px; color: var(--text3); font-weight: 700;
}
.wc-submitted-notice {
  text-align: center; padding: 32px 20px;
  color: var(--text2);
}
.wc-submitted-notice .icon { font-size: 42px; margin-bottom: 12px; }
.wc-submitted-notice p { font-size: 14px; font-weight: 800; }
.wc-session-history {
  margin-top: 20px;
}
.wc-history-item {
  background: var(--surface); border: 1.5px solid var(--border);
  border-radius: var(--r-sm); padding: 10px 14px;
  margin-bottom: 8px; font-size: 13px;
  display: flex; justify-content: space-between; align-items: center;
  cursor: pointer; transition: all 0.15s;
}
.wc-history-item:hover { border-color: var(--wc-accent, #c8974a); background: var(--wc-bg, #faf8f4); }

/* ══ 반응형 ══ */
@media (max-width: 1024px) {
  .wc-layout { grid-template-columns: 1fr; }
  .wc-setup-pane { border-right: none; border-bottom: 1.5px solid var(--wc-border, #e8dfc8); max-height: none; }
  .wc-live-pane { max-height: none; }
}
@media (max-width: 768px) {
  .t-sidebar {
    position: fixed; left: -260px; top: 0; height: 100%; z-index: 200;
    box-shadow: var(--shadow-md);
  }
  .t-sidebar.open { transform: translateX(260px); }
  .sidebar-toggle { display: flex; align-items: center; justify-content: center; background: none; border: none; font-size: 22px; cursor: pointer; color: var(--text2); padding: 4px; }
  .sidebar-overlay.show { display: block; }
  .t-topbar { padding: 0 16px; }
  .t-panel { padding: 16px; }
  .student-card-grid { grid-template-columns: repeat(3, 1fr); }
  .assignment-card-grid { grid-template-columns: repeat(2, 1fr); }
  .assignment-detail-grid { grid-template-columns: repeat(2, 1fr); }
  .wc-setup-pane, .wc-live-pane { padding: 16px; }
  .nav-user-info .nav-name-text { display: none; }
  .wc-qr-area { flex-direction: column; align-items: center; }
  .wc-qr-box canvas { width: 140px !important; height: 140px !important; }
}
@media (max-width: 480px) {
  .s-nav { padding: 0 14px; }
  .nav-brand-main { font-size: 22px; }
  .student-card-grid { grid-template-columns: repeat(2, 1fr); }
  .assignment-grid { grid-template-columns: 1fr 1fr; }
  .t-topbar-title { font-size: 15px; }
  .login-logo h1 { font-size: 38px; }
}
</style>
</head>
<body>

<div class="loading-overlay hidden" id="loading">
  <div class="spinner"></div>
  <p id="loading-text">불러오는 중...</p>
</div>
<div class="toast" id="toast"></div>
<div class="sidebar-overlay" id="sidebar-overlay" onclick="closeSidebar()"></div>

<!-- ══ 로그인 ══ -->
<div class="page active" id="page-login" style="display:flex;">
  <div class="login-wrap">
    <div class="login-logo">
      <div class="login-logo-icon">✏️</div>
      <h1>Done? Done!</h1>
      <div class="login-logo-sub">냈어? 냈어!</div>
      <p>수업 과제 제출 시스템</p>
      <div class="login-teacher-name hidden" id="login-teacher-name"></div>
    </div>
    <div class="login-box">
      <div class="form-group">
        <input type="text" id="student-code" maxlength="6"
          placeholder="학생 코드 6자리 (예: A3K9M2)"
          oninput="this.value=this.value.toUpperCase()"
          onkeydown="if(event.key==='Enter')loginStudent()">
      </div>
      <label class="login-remember">
        <input type="checkbox" id="remember-code">
        <span>이 기기에서 자동 로그인 (내 태블릿·내 컴퓨터에서만 체크)</span>
      </label>
      <button class="btn-grad" onclick="loginStudent()">학생으로 접속</button>
      <div class="login-divider">교사 전용</div>
      <div class="form-group">
        <input type="password" id="teacher-pw" placeholder="교사 비밀번호"
          onkeydown="if(event.key==='Enter')loginTeacher()">
      </div>
      <button class="btn-teacher" onclick="loginTeacher()">🏫 교사로 접속</button>
    </div>
    <div class="login-footer">
      <div><a class="insta-link" href="https://instagram.com/hirame.ki" target="_blank" rel="noopener">
        <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
          <rect x="2" y="2" width="20" height="20" rx="5" ry="5"/>
          <path d="M16 11.37A4 4 0 1 1 12.63 8 4 4 0 0 1 16 11.37z"/>
          <line x1="17.5" y1="6.5" x2="17.51" y2="6.5"/>
        </svg>
        제작 @hirame.ki
      </a></div>
      <div style="font-size:10px;margin-top:2px;color:#c0c0c0">Done? Done! &mdash; 냈어? 냈어! 😄 &nbsp;©2026</div>
    </div>
  </div>
</div>

<!-- ══ 학생 화면 ══ -->
<div class="page" id="page-student">
  <nav class="s-nav">
    <div class="nav-brand">
      <span class="nav-brand-main">✏️ Done? Done!</span>
      <span class="nav-brand-sub">냈어? 냈어!</span>
    </div>
    <div class="nav-user-info">
      <div class="nav-avatar" id="s-avatar">?</div>
      <span style="font-weight:800" id="s-name" class="nav-name-text"></span>
      <span style="color:var(--text3);font-size:12px;font-weight:700" id="s-class"></span>
      <button class="btn-logout" onclick="logout()">로그아웃</button>
    </div>
  </nav>
  <div class="s-tabs">
    <button class="tab-btn active" onclick="switchSTab('submit',event)">과제 제출</button>
    <button class="tab-btn" onclick="switchSTab('my',event)">내 제출물 · 피드백</button>
  </div>
  <div id="s-tab-submit" class="s-container">
    <div class="section-header">
      <h2>과제 목록</h2>
      <span style="display:flex;gap:8px;align-items:center;font-size:12px;font-weight:700;color:var(--text3)">
        <span style="background:var(--submitted);color:var(--submitted-text);padding:2px 8px;border-radius:12px">✅ 제출</span>
        <span style="background:var(--notsubmit);color:var(--notsubmit-text);padding:2px 8px;border-radius:12px">❌ 미제출</span>
      </span>
    </div>
    <div id="assignment-list" class="assignment-grid">
      <div class="empty-state" style="grid-column:1/-1"><div class="icon">📋</div><p>불러오는 중...</p></div>
    </div>
    <!-- 이미 제출한 과제 — 안내를 다시 볼 수 있는 읽기 전용 화면 -->
    <div class="submit-form hidden" id="assignment-view">
      <div style="display:flex;align-items:center;justify-content:space-between;gap:10px;margin-bottom:14px">
        <h3 id="assignment-view-title" style="margin:0"></h3>
        <button class="btn-outline btn-sm" onclick="closeAssignmentView()">닫기</button>
      </div>
      <div id="assignment-view-body"></div>
    </div>

    <div class="submit-form hidden" id="submit-form">
      <h3 id="submit-form-title">과제 제출</h3>
      <div id="assignment-file-view" class="hidden" style="margin-bottom:16px"></div>
      <div class="form-group">
        <label>활동 내용 *</label>
        <textarea id="sub-content" placeholder="이번 수업에서 한 활동, 느낀 점, 배운 점 등을 자유롭게 적어주세요."></textarea>
      </div>
      <div class="form-group">
        <label>파일 첨부 (선택) — 이미지 또는 PDF · 여러 개 첨부 가능</label>
        <div class="file-drop-zone" id="s-drop-zone"
          ondragover="handleDragOver(event,'s-drop-zone')"
          ondragleave="handleDragLeave('s-drop-zone')"
          ondrop="handleDrop(event,'s-file-input','s-file-preview','student')">
          <input type="file" id="s-file-input" accept="image/*,.pdf" multiple
            onchange="handleFileSelect(this,'s-file-preview','student')">
          <div class="file-drop-icon">📎</div>
          <div class="file-drop-text">파일을 드래그하거나 클릭하여 선택 (여러 개 가능)</div>
          <div class="file-drop-hint">이미지(JPG, PNG 등) · PDF · 파일당 최대 50MB</div>
        </div>
        <div id="s-upload-progress" class="upload-progress hidden">
          <div class="mini-spinner"></div><span>Drive에 업로드 중...</span>
        </div>
        <div id="s-file-preview"></div>
      </div>
      <div class="form-actions">
        <button class="btn-outline" onclick="cancelSubmit()">취소</button>
        <button class="btn-primary" onclick="submitAssignment()">제출하기</button>
      </div>
    </div>
  </div>
  <div id="s-tab-my" class="s-container hidden">
    <div class="section-header">
      <h2>내 제출물 · 피드백</h2>
      <button class="btn-outline btn-sm" onclick="loadMySubmissions()">🔄 새로고침</button>
    </div>
    <div id="my-stamp-hero"></div>
    <div id="my-submissions-list">
      <div class="empty-state"><div class="icon">📝</div><p>불러오는 중...</p></div>
    </div>
  </div>
</div>

<!-- ══ 워드클라우드 학생 응답 페이지 ══ -->
<div class="page" id="page-wc-student">
  <div class="wc-student-wrap">
    <div class="wc-student-header">
      <div class="wc-app-name">☁️ 우리 반 생각 구름</div>
      <div class="wc-app-sub" id="wc-s-teacher-name">선생님의 질문에 답해주세요</div>
    </div>
    <div class="wc-student-question-box">
      <div class="q-label">📣 질문</div>
      <div class="q-text" id="wc-s-question">질문을 불러오는 중...</div>
    </div>
    <div class="wc-student-answer-box" id="wc-s-answer-area">
      <div class="form-group" style="margin-bottom:0">
        <input type="text" id="wc-s-input" class="wc-student-input"
          placeholder="단어 또는 짧은 문장을 입력하세요"
          maxlength="20"
          onkeydown="if(event.key==='Enter')wcStudentSubmit()">
      </div>
      <button class="wc-student-submit-btn" onclick="wcStudentSubmit()">✉️ 의견 보내기</button>
      <div class="wc-remain-count" id="wc-s-remain"></div>
    </div>
    <div class="wc-submitted-notice hidden" id="wc-s-done">
      <div class="icon">🎉</div>
      <p>모든 의견을 제출했습니다!</p>
      <p style="font-size:12px;color:var(--text3);margin-top:6px;font-weight:400">선생님 화면에서 워드클라우드를 확인하세요.</p>
    </div>
    <div style="margin-top:16px;text-align:center;font-size:11px;color:var(--text3)">
      ✏️ Done? Done! · @hirame.ki
    </div>
  </div>
</div>

<!-- ══ 교사 화면 ══ -->
<div class="page" id="page-teacher">
  <aside class="t-sidebar" id="t-sidebar">
    <div class="t-sidebar-brand">
      <span class="brand-logo">✏️ Done? Done!</span>
      <span class="brand-sub-ko">냈어? 냈어!</span>
      <span class="brand-sub" id="teacher-name-sidebar">교사 대시보드</span>
    </div>
    <div class="t-sidebar-class">
      <div class="class-label">내 클래스</div>
      <div id="sidebar-class-list"></div>
      <button class="btn-add-class" onclick="showAddClassModal()">＋ 클래스 추가</button>
    </div>
    <div id="entered-class-banner" class="hidden">
      <div class="entered-class-banner">
        <span id="entered-class-name">클래스명</span>
        <button class="btn-exit-class" onclick="exitClass()">← 나가기</button>
      </div>
    </div>
    <div class="t-sidebar-menu hidden" id="t-sidebar-menu">
      <button class="menu-item" id="menu-students" onclick="showTeacherPanel('students');closeSidebar()">
        <span class="menu-icon">👤</span> 학생별 보기
      </button>
      <button class="menu-item" id="menu-assignments" onclick="showTeacherPanel('assignments');closeSidebar()">
        <span class="menu-icon">📋</span> 과제별 보기
      </button>
      <button class="menu-item" id="menu-matrix" onclick="showTeacherPanel('matrix');closeSidebar()">
        <span class="menu-icon">📊</span> 현황판
      </button>
      <button class="menu-item" id="menu-stamps" onclick="showTeacherPanel('stamps');closeSidebar()">
        <span class="menu-icon">🏅</span> 도장 · 학급공약
      </button>
      <button class="menu-item" id="menu-manage-assign" onclick="showTeacherPanel('manage-assign');closeSidebar()">
        <span class="menu-icon">➕</span> 과제 관리
      </button>
      <button class="menu-item" id="menu-manage-students" onclick="showTeacherPanel('manage-students');closeSidebar()">
        <span class="menu-icon">👥</span> 학생 관리
      </button>
    </div>

    <!-- ██ 워드클라우드 사이드바 섹션 ██ -->
    <div class="wc-sidebar-section">
      <div class="wc-sidebar-label">
        <span>☁️ 워드클라우드</span>
        <span class="wc-live-dot" id="wc-live-dot"></span>
      </div>
      <button class="wc-menu-btn" id="wc-menu-btn" onclick="showTeacherPanel('wordcloud');closeSidebar()">
        <span>🖥️</span> 워드클라우드 열기
      </button>
    </div>

    <div class="t-sidebar-footer">
      <button class="btn-logout" onclick="logout()">로그아웃</button>
    </div>
  </aside>

  <main class="t-main">
    <div class="t-topbar">
      <div style="display:flex;align-items:center;gap:12px">
        <button class="sidebar-toggle" onclick="openSidebar()">☰</button>
        <div class="t-topbar-title" id="t-topbar-title">학생별 보기</div>
      </div>
      <div class="t-topbar-actions" id="t-topbar-actions"></div>
    </div>

    <!-- 패널: 학생별 보기 -->
    <div class="t-panel active" id="panel-students">
      <div id="student-cards-view">
        <div class="class-overview-header">
          <h2 id="selected-class-title">클래스를 선택하세요</h2>
          <div class="overview-stats" id="overview-stats"></div>
        </div>
        <div id="student-card-grid" class="student-card-grid">
          <div class="empty-state" style="grid-column:1/-1"><div class="icon">👈</div><p>왼쪽에서 클래스를 선택하세요</p></div>
        </div>
      </div>
      <div id="student-detail-view" class="hidden">
        <div class="student-detail-header">
          <button class="back-btn" onclick="backToStudentCards()">← 학생 목록</button>
          <h2 id="student-detail-title"></h2>
          <button class="excel-btn" onclick="downloadStudentExcel()">📊 생기부 자료 다운로드</button>
        </div>
        <div id="student-assignment-grid" class="assignment-grid"></div>
        <div id="student-submission-detail" class="hidden"></div>
      </div>
    </div>

    <!-- 패널: 과제별 보기 -->
    <div class="t-panel" id="panel-assignments">
      <div id="assignment-cards-view">
        <div class="section-header"><h2>전체 과제 목록</h2></div>
        <div id="assignment-card-grid" class="assignment-card-grid">
          <div class="empty-state" style="grid-column:1/-1"><div class="icon">📋</div><p>불러오는 중...</p></div>
        </div>
      </div>
      <div id="assignment-detail-view" class="hidden">
        <div class="student-detail-header">
          <button class="back-btn" onclick="backToAssignmentCards()">← 과제 목록</button>
          <h2 id="assignment-detail-title"></h2>
          <button class="excel-btn" onclick="downloadAssignmentExcel()">📊 생기부 자료 다운로드</button>
        </div>
        <div class="overview-stats" id="assignment-stats" style="margin-bottom:16px"></div>
        <div id="assignment-student-grid" class="assignment-detail-grid"></div>
      </div>
    </div>

    <!-- 패널: 과제 관리 -->
    <div class="t-panel" id="panel-manage-assign">
      <div class="submit-form" style="max-width:600px;margin-bottom:24px">
        <h3>새 과제 등록</h3>
        <div class="form-group"><label>과제명 *</label><input type="text" id="new-a-title" placeholder="예: 1차시 활동지"></div>
        <div class="form-group"><label>설명</label><textarea id="new-a-desc" placeholder="과제 안내 내용" style="min-height:70px"></textarea></div>
        <div class="form-row">
          <div class="form-group"><label>수업장소</label><select id="new-a-class"><option value="">전체 공개</option></select></div>
          <div class="form-group"><label>마감일</label><input type="date" id="new-a-due"></div>
        </div>
        <div class="form-group">
          <label>과제 참고 파일 (선택)</label>
          <div class="file-drop-zone" id="t-drop-zone"
            ondragover="handleDragOver(event,'t-drop-zone')"
            ondragleave="handleDragLeave('t-drop-zone')"
            ondrop="handleDrop(event,'t-file-input','t-file-preview','teacher')">
            <input type="file" id="t-file-input" accept="image/*,.pdf" multiple
              onchange="handleFileSelect(this,'t-file-preview','teacher')">
            <div class="file-drop-icon">📎</div>
            <div class="file-drop-text">파일을 드래그하거나 클릭하여 선택 (여러 개 가능)</div>
            <div class="file-drop-hint">이미지(JPG, PNG 등) · PDF · 파일당 최대 50MB</div>
          </div>
          <div id="t-upload-progress" class="upload-progress hidden"><div class="mini-spinner"></div><span>Drive에 업로드 중...</span></div>
          <div id="t-file-preview"></div>
        </div>
        <div class="form-actions"><button class="btn-primary" onclick="addAssignment()">등록</button></div>
      </div>
      <div class="section-header"><h2>등록된 과제 목록</h2></div>
      <div id="t-assignment-list"><div class="empty-state"><div class="icon">📋</div><p>불러오는 중...</p></div></div>
    </div>

    <!-- 패널: 학생 관리 -->
    <div class="t-panel" id="panel-manage-students">
      <div class="section-header">
        <h2>학생 목록</h2>
        <div style="display:flex;gap:8px">
          <button class="btn-outline btn-sm" onclick="showBulkAddModal()">📋 일괄 등록</button>
          <button class="btn-primary btn-sm" onclick="showAddStudentForm()">+ 학생 추가</button>
        </div>
      </div>
      <div class="submit-form hidden" id="add-student-form" style="max-width:600px;margin-bottom:16px">
        <h3>학생 추가</h3>
        <div class="form-row">
          <div class="form-group"><label>수업장소(클래스) *</label><select id="new-s-class"><option value="">클래스 선택</option></select></div>
          <div class="form-group"><label>학번</label><input type="text" id="new-s-number" placeholder="예: 20301"></div>
          <div class="form-group"><label>이름 *</label><input type="text" id="new-s-name" placeholder="홍길동"></div>
        </div>
        <div class="form-actions">
          <button class="btn-outline" onclick="hideAddStudentForm()">취소</button>
          <button class="btn-primary" onclick="addStudent()">추가</button>
        </div>
      </div>
      <div style="display:flex;gap:6px;flex-wrap:wrap;margin-bottom:14px" id="student-class-filter">
        <button class="chip chip-blue" onclick="filterStudentsByClass('all',this)" style="cursor:pointer">전체</button>
      </div>
      <div class="card student-table-wrap">
        <table>
          <thead><tr>
            <th onclick="sortStudentTable(0)">코드</th>
            <th onclick="sortStudentTable(1)">이름</th>
            <th onclick="sortStudentTable(2)">수업장소</th>
            <th onclick="sortStudentTable(3)">학번</th>
            <th style="width:70px">관리</th>
          </tr></thead>
          <tbody id="student-tbody"></tbody>
        </table>
      </div>
    </div>

    <!-- 패널: 현황판 -->
    <div class="t-panel" id="panel-matrix">
      <div class="section-header">
        <h2>현황판 — 학생 × 과제</h2>
        <div style="display:flex;gap:8px;align-items:center">
          <select id="matrix-sort" onchange="renderMatrix()" style="padding:5px 10px;border:1.5px solid var(--border);border-radius:var(--r-sm);font-size:12px;font-family:'Nanum Gothic',sans-serif;background:var(--bg);">
            <option value="name">학생명 순</option>
            <option value="number">학번 순</option>
            <option value="submit_asc">제출수 적은 순</option>
            <option value="submit_desc">제출수 많은 순</option>
          </select>
          <button class="btn-outline btn-sm" onclick="loadMatrixView()">🔄 새로고침</button>
        </div>
      </div>
      <div id="matrix-container" class="matrix-wrap">
        <div class="empty-state"><div class="icon">📊</div><p>클래스를 선택하면 표시됩니다.</p></div>
      </div>
    </div>

    <!-- 패널: 도장 · 학급공약 -->
    <div class="t-panel" id="panel-stamps">
      <div class="section-header">
        <h2>🏅 도장 · 학급공약</h2>
        <button class="btn-outline btn-sm" onclick="loadStampBoard()">🔄 새로고침</button>
      </div>
      <div id="stamp-board">
        <div class="empty-state"><div class="icon">🏅</div><p>클래스를 선택하면 표시됩니다.</p></div>
      </div>
    </div>

    <!-- ██ 패널: 워드클라우드 ██ -->
    <div class="t-panel" id="panel-wordcloud">
      <div class="wc-layout">

        <!-- 왼쪽: 설정 -->
        <div class="wc-setup-pane">
          <div class="wc-steps" id="wc-steps">
            <span class="wc-step active" id="wc-step1">① 질문 설정</span>
            <span class="step-arrow">›</span>
            <span class="wc-step" id="wc-step2">② 응답 수집</span>
            <span class="step-arrow">›</span>
            <span class="wc-step" id="wc-step3">③ 결과</span>
          </div>

          <div class="wc-section-label">질문</div>
          <textarea class="wc-question-input" id="wc-question"
            placeholder="학생들에게 물어볼 질문을 입력하세요"
            rows="3"></textarea>

          <div style="margin-top:14px">
            <div class="wc-section-label">자주 쓰는 질문</div>
            <div class="wc-preset-chips" id="wc-preset-chips">
              <span class="wc-preset-chip" onclick="setWcQuestion(this.textContent)">이 주제에 대해 떠오르는 단어는?</span>
              <span class="wc-preset-chip" onclick="setWcQuestion(this.textContent)">수업 후 느낀 점 한 단어로?</span>
              <span class="wc-preset-chip" onclick="setWcQuestion(this.textContent)">오늘 기분을 한 단어로!</span>
              <span class="wc-preset-chip" onclick="setWcQuestion(this.textContent)">이번 학기 목표 키워드는?</span>
              <span class="wc-preset-chip" onclick="setWcQuestion(this.textContent)">이 작품의 인상을 한 단어로?</span>
            </div>
            <div class="wc-preset-actions">
              <button class="wc-btn-sm" onclick="wcLoadPresets()">🗂 불러오기</button>
              <button class="wc-btn-sm" onclick="wcSavePreset()">💾 프리셋 저장</button>
            </div>
          </div>

          <div class="wc-count-row">
            <span class="wc-count-label">1인당 제출 횟수</span>
            <div class="wc-count-ctrl">
              <button class="wc-count-btn" onclick="adjustWcCount(-1)">−</button>
              <div class="wc-count-display" id="wc-count-display">5</div>
              <button class="wc-count-btn" onclick="adjustWcCount(1)">＋</button>
            </div>
          </div>

          <div class="wc-session-link" onclick="wcShowHistory()">
            🕐 세션 기록
          </div>

          <button class="wc-start-btn" id="wc-start-btn" onclick="wcStartSession()">
            ☁️ 워드클라우드 시작!
          </button>
          <button class="wc-stop-btn hidden" id="wc-stop-btn" onclick="wcStopSession()">
            ⏹ 세션 종료
          </button>

          <!-- 세션 기록 -->
          <div id="wc-history-panel" class="hidden wc-session-history">
            <div class="wc-section-label" style="margin-top:16px">세션 기록</div>
            <div id="wc-history-list"></div>
          </div>
        </div>

        <!-- 오른쪽: 라이브 뷰 -->
        <div class="wc-live-pane" id="wc-live-pane">
          <div class="wc-live-header">
            <div style="font-size:15px;font-weight:800;color:var(--text2)">☁️ 실시간 워드클라우드</div>
            <button class="wc-btn-sm hidden" id="wc-fullscreen-btn" onclick="wcToggleFullscreen()">🔲 전체화면</button>
          </div>

          <!-- 질문 표시 (활성화 후) -->
          <div class="wc-live-question hidden" id="wc-live-question">
            <span class="wc-q-label">📣 현재 질문</span>
            <span class="wc-q-text" id="wc-live-q-text"></span>
          </div>

          <!-- QR + 통계 -->
          <div class="wc-qr-area hidden" id="wc-qr-area">
            <div class="wc-qr-box" id="wc-qr-box">
              <button class="wc-qr-full-btn" id="wc-qr-full-btn" onclick="wcToggleQrFullscreen()" title="QR 전체화면으로 크게 보기">⛶</button>
              <canvas id="wc-qr-canvas" width="140" height="140"></canvas>
              <div class="wc-qr-url" id="wc-qr-url"></div>
              <div class="wc-qr-shorten-status" id="wc-qr-shorten-status"></div>
            </div>
            <div class="wc-stats-box">
              <div class="wc-stat-item">
                <span class="wc-stat-label">응답 수</span>
                <span class="wc-stat-val" id="wc-response-count">0</span>
              </div>
              <div class="wc-stat-item">
                <span class="wc-stat-label">고유 단어</span>
                <span class="wc-stat-val" id="wc-word-count">0</span>
              </div>
              <div class="wc-stat-item">
                <span class="wc-stat-label">참여 인원</span>
                <span class="wc-stat-val" id="wc-participant-count">0</span>
              </div>
            </div>
          </div>

          <!-- 워드클라우드 캔버스 -->
          <div class="wc-canvas-wrap" id="wc-canvas-wrap" style="display:none">
            <canvas id="wc-canvas"></canvas>
          </div>

          <!-- 빈 상태 -->
          <div class="empty-state" id="wc-empty-state">
            <div class="icon">☁️</div>
            <p>질문을 설정하고 워드클라우드를 시작하세요</p>
            <p style="font-size:12px;margin-top:6px">학생들이 QR코드로 접속하여 답변을 입력합니다</p>
          </div>

          <!-- 응답 목록 -->
          <div id="wc-responses-wrap" style="display:none">
            <div style="font-size:12px;font-weight:800;color:var(--text2);margin-bottom:8px">수집된 답변</div>
            <div class="wc-responses-list" id="wc-responses-list"></div>
          </div>
        </div>

      </div><!-- .wc-layout -->
    </div><!-- #panel-wordcloud -->

  </main>
</div><!-- #page-teacher -->

<!-- 제출물 확인 모달 -->
<div class="modal-overlay hidden" id="submission-modal" onclick="if(event.target===this)closeModal()">
  <div class="modal">
    <div class="modal-header">
      <h3 id="modal-title">제출물 확인</h3>
      <button class="modal-close" onclick="closeModal()">✕</button>
    </div>
    <div class="modal-body">
      <div class="sub-meta" id="modal-meta" style="margin-bottom:12px;font-size:12px;color:var(--text3);font-weight:700"></div>
      <div class="modal-content-text" id="modal-content"></div>
      <div id="modal-file-view"></div>
      <div style="margin-top:16px">
        <div id="modal-existing-feedback"></div>
        <div class="form-group" style="margin-top:12px">
          <label>피드백 작성</label>
          <textarea id="modal-fb-input" placeholder="학생에게 전달할 피드백을 입력하세요." style="min-height:80px"></textarea>
        </div>
        <div class="sticker-selector">
          <div class="sticker-selector-label">칭찬 스티커</div>
          <div class="sticker-options">
            <span class="sticker-opt selected" data-sticker="⭐" onclick="selectSticker(this)">⭐</span>
            <span class="sticker-opt" data-sticker="🌟" onclick="selectSticker(this)">🌟</span>
            <span class="sticker-opt" data-sticker="🏆" onclick="selectSticker(this)">🏆</span>
            <span class="sticker-opt" data-sticker="🎖️" onclick="selectSticker(this)">🎖️</span>
            <span class="sticker-opt" data-sticker="🌈" onclick="selectSticker(this)">🌈</span>
            <span class="sticker-opt" data-sticker="💯" onclick="selectSticker(this)">💯</span>
            <span class="sticker-opt" data-sticker="👏" onclick="selectSticker(this)">👏</span>
            <span class="sticker-opt" data-sticker="🎉" onclick="selectSticker(this)">🎉</span>
            <span class="sticker-opt" data-sticker="" onclick="selectSticker(this)" title="스티커 없음" style="font-size:13px;font-weight:800;color:var(--text3)">없음</span>
          </div>
        </div>
        <div class="sticker-selector" style="margin-bottom:0">
          <div class="sticker-selector-label">참 잘했어요 도장</div>
          <div class="stamp-options">
            <span class="stamp-opt selected" data-stamps="0" onclick="selectStamp(this)">안 줌</span>
            <span class="stamp-opt" data-stamps="1" onclick="selectStamp(this)">🏅 1개</span>
            <span class="stamp-opt" data-stamps="2" onclick="selectStamp(this)">🏅🏅 2개</span>
            <span class="stamp-opt" data-stamps="3" onclick="selectStamp(this)">🏅🏅🏅 3개</span>
          </div>
          <div class="stamp-hint">피드백을 다시 저장하면 도장은 여기서 고른 개수로 바뀝니다. (더해지지 않습니다)</div>
        </div>
      </div>
    </div>
    <div class="modal-footer">
      <button class="btn-red" onclick="doRejectSubmission()">반려</button>
      <button class="btn-outline" onclick="closeModal()">닫기</button>
      <button class="btn-primary" onclick="doSaveFeedback()">피드백 저장</button>
    </div>
  </div>
</div>

<!-- 클래스 추가 모달 -->
<div class="modal-overlay hidden" id="add-class-modal" onclick="if(event.target===this)closeAddClassModal()">
  <div class="modal-sm">
    <h3 style="font-size:16px;font-weight:800;margin-bottom:16px">클래스 추가</h3>
    <div class="form-group">
      <input type="text" id="new-class-name" placeholder="예: 3-1" onkeydown="if(event.key==='Enter')addClassRoom()">
    </div>
    <div class="form-actions">
      <button class="btn-outline" onclick="closeAddClassModal()">취소</button>
      <button class="btn-primary" onclick="addClassRoom()">추가</button>
    </div>
  </div>
</div>

<!-- 클래스명 수정 모달 -->
<div class="modal-overlay hidden" id="rename-class-modal" onclick="if(event.target===this)closeRenameClassModal()">
  <div class="modal-sm">
    <h3 style="font-size:16px;font-weight:800;margin-bottom:6px">클래스명 수정</h3>
    <p style="font-size:12px;color:var(--text3);font-weight:700;margin-bottom:14px">이 클래스의 학생과 과제도 새 이름으로 함께 옮겨집니다.</p>
    <div class="form-group">
      <input type="text" id="rename-class-name" placeholder="예: 3-1" onkeydown="if(event.key==='Enter')submitRenameClass()">
    </div>
    <div class="form-actions">
      <button class="btn-outline" onclick="closeRenameClassModal()">취소</button>
      <button class="btn-primary" onclick="submitRenameClass()">저장</button>
    </div>
  </div>
</div>

<!-- 학생명 수정 모달 -->
<div class="modal-overlay hidden" id="rename-student-modal" onclick="if(event.target===this)closeRenameStudentModal()">
  <div class="modal-sm">
    <h3 style="font-size:16px;font-weight:800;margin-bottom:6px">학생명 수정</h3>
    <p style="font-size:12px;color:var(--text3);font-weight:700;margin-bottom:14px" id="rename-student-hint"></p>
    <div class="form-group">
      <input type="text" id="rename-student-name" placeholder="예: 홍길동" onkeydown="if(event.key==='Enter')submitRenameStudent()">
    </div>
    <div class="form-actions">
      <button class="btn-outline" onclick="closeRenameStudentModal()">취소</button>
      <button class="btn-primary" onclick="submitRenameStudent()">저장</button>
    </div>
  </div>
</div>

<!-- 학생 일괄 등록 모달 -->
<div class="modal-overlay hidden" id="bulk-add-modal" onclick="if(event.target===this)closeBulkAddModal()">
  <div class="modal" style="max-width:520px">
    <div class="modal-header">
      <h3>학생 일괄 등록</h3>
      <button class="modal-close" onclick="closeBulkAddModal()">✕</button>
    </div>
    <div class="modal-body">
      <div class="form-group" style="margin-bottom:10px">
        <label>수업장소(클래스) *</label>
        <select id="bulk-s-class"><option value="">클래스 선택</option></select>
      </div>
      <div class="form-group">
        <label>학번 · 이름 목록 *</label>
        <textarea id="bulk-s-list" style="min-height:180px;font-family:monospace;font-size:13px;line-height:1.8"
          placeholder="한 줄에 한 명씩 입력하세요.
형식: 학번 이름  (공백으로 구분)
예시:
20301 홍길동
20302 김철수"></textarea>
      </div>
      <div id="bulk-preview" style="margin-top:8px;font-size:12px;color:var(--text2);font-weight:700"></div>
    </div>
    <div class="modal-footer">
      <button class="btn-outline" onclick="closeBulkAddModal()">취소</button>
      <button class="btn-primary" onclick="doBulkAddStudents()">📋 일괄 등록</button>
    </div>
  </div>
</div>

<script>
// ══════════════════════════════════════════════════════
// 기존 Done? Done! 로직
// ══════════════════════════════════════════════════════
const API_BASE = window.location.href.split('?')[0];

let currentStudent = null;
let teacherPw = null;
let allAssignments = [];
let allStudents = [];
let mySubmissions = [];
let selectedAssignmentId = null;
let currentClassFilter = 'all';
let _tableSortDir = {};
let teacherUploadedFiles = [];
let studentUploadedFiles = [];
let editAssignUploadedFiles = [];
let selectedClass = null;
let selectedStudentCode = null;
let allSubmissions = [];
let modalSubId = null;
let modalStudentCode = null;
let modalAssignmentId = null;
let selectedSticker = '⭐';
let selectedStamps = 0;      // 피드백 모달에서 고른 도장 개수 (0~3)
let stampBoard = null;       // 교사 도장 현황판 데이터
let allClasses = [];
let enteredClass = null;
let studentDetailExportData = null;     // 학생별 보기 상세에서 뽑은 엑셀용 데이터 캐시
let assignmentDetailExportData = null;  // 과제별 보기 상세에서 뽑은 엑셀용 데이터 캐시
let matrixData = { students:[], assignments:[], submissions:[] };
let teacherName = '';
// ★ 자동 로그인용 localStorage 키. 아래 initApp()이 바로 실행되면서 이 값을 읽으므로
//   반드시 initApp() 호출보다 위에 선언해 둬야 한다.
//   (아래쪽에 두면 const가 아직 초기화 전이라 ReferenceError가 나고,
//    getRememberedCode의 try/catch가 그걸 삼켜서 "자동 로그인이 조용히 안 되는" 버그가 된다.)
const REMEMBER_KEY = 'dd_student_code';

async function initApp() {
  try {
    // ★ 워드클라우드 QR(?wc=)로 들어온 경우에는 자동 로그인을 하지 않는다.
    //   저 아래 wc 감지 코드가 페이지를 워드클라우드 화면으로 바꾸는데,
    //   자동 로그인이 뒤늦게 응답을 받고 학생 화면으로 덮어버리면 QR 참여가 깨진다.
    const isWcEntry = !!(document.querySelector('meta[name="wc-session-id"]')
      || new URLSearchParams(window.location.search).get('wc'));

    const savedCode = isWcEntry ? '' : getRememberedCode();
    if (savedCode) {
      document.getElementById('remember-code').checked = true;
      document.getElementById('student-code').value = savedCode;
      showLoading("자동 접속 중...");
    }

    // ★ 설정 조회와 자동 로그인을 한꺼번에 던진다.
    //   순서대로 await 하면 학생이 앱 열 때마다 시트 왕복이 두 번 겹쳐서 느려진다.
    const wrap = p => p.then(res => ({ ok:true, res }), err => ({ ok:false, err }));
    const [setOut, loginOut] = await Promise.all([
      wrap(api({ action:'getSettings' })),
      savedCode ? wrap(api({ action:'login', code:savedCode })) : null
    ]);

    if (setOut.ok && setOut.res && setOut.res.success) {
      const res = setOut.res;
      if (res.theme && res.theme !== '기본') applyTheme(res.theme);
      if (res.teacherName) {
        teacherName = res.teacherName;
        const el = document.getElementById('login-teacher-name');
        el.textContent = '👨‍🏫 ' + res.teacherName + ' 선생님';
        el.classList.remove('hidden');
      }
    }

    if (!loginOut) return;
    hideLoading();
    if (loginOut.ok && loginOut.res && loginOut.res.success) {
      enterStudentApp(loginOut.res.student);
    } else if (loginOut.ok) {
      // 서버가 "그런 코드 없다"고 답한 경우 — 선생님이 학생을 지웠거나 코드가 바뀐 것이니 저장을 버린다.
      forgetRememberedCode();
      document.getElementById('student-code').value = '';
      toast("저장된 코드로 접속할 수 없어요. 코드를 다시 입력해주세요.");
    } else {
      // 통신 실패는 코드 잘못이 아니다. 저장은 그대로 두고 직접 로그인만 기다린다.
      toast("자동 접속에 실패했어요. '학생으로 접속'을 눌러주세요.");
    }
  } catch(e) {
    // ★ 무슨 일이 있어도 로딩 화면에 갇히면 안 된다.
    hideLoading();
  }
}
function applyTheme(theme) {
  document.documentElement.setAttribute('data-theme', theme);
}
try { initApp(); } catch(e) {}

async function api(params) {
  return new Promise((resolve, reject) => {
    google.script.run
      .withSuccessHandler(text => {
        try { resolve(JSON.parse(text)); }
        catch(e) { reject(new Error('응답 파싱 오류: ' + String(text).slice(0,100))); }
      })
      .withFailureHandler(err => reject(new Error('서버 통신 오류: ' + err.message)))
      .apiHandler(params);
  });
}

function showLoading(msg="불러오는 중...") {
  document.getElementById("loading-text").textContent = msg;
  document.getElementById("loading").classList.remove("hidden");
}
function hideLoading() { document.getElementById("loading").classList.add("hidden"); }
function toast(msg) {
  const el = document.getElementById("toast");
  el.textContent = msg;
  el.classList.add("show");
  setTimeout(() => el.classList.remove("show"), 2800);
}
function showPage(id) {
  document.querySelectorAll(".page").forEach(p => {
    p.style.display = 'none'; p.classList.remove("active");
  });
  const t = document.getElementById(id);
  // ★ flex로 배치하는 페이지는 목록으로 관리한다.
  //   로그인 화면(#page-login)은 flex 가운데 정렬로 카드를 중앙에 놓는데,
  //   로그아웃 뒤 여기서 인라인 display:block을 씌우는 바람에 정렬이 풀려
  //   카드가 왼쪽에 붙어 버렸다.
  const FLEX_PAGES = ['page-login', 'page-teacher', 'page-wc-student'];
  t.style.display = FLEX_PAGES.indexOf(id) >= 0 ? 'flex' : 'block';
  t.classList.add("active");
}
// ★ 작은따옴표까지 이스케이프한다.
//   onclick="fn('${...}')" 처럼 작은따옴표 안에 값을 넣는 곳이 많아서,
//   이름·과제명에 ' 가 들어가면 핸들러가 통째로 깨졌다.
function escHtml(str) {
  return String(str==null?"":str)
    .replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;")
    .replace(/"/g,"&quot;").replace(/'/g,"&#39;");
}
// onclick='...' 안에 들어가는 값 전용 (JS 문자열 리터럴로 안전하게)
function escAttr(str) {
  return String(str==null?"":str)
    .replace(/\\/g,"\\\\").replace(/'/g,"\\'").replace(/"/g,"&quot;")
    .replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/\r?\n/g," ");
}
function fmtDate(str) {
  if (!str) return '';
  return String(str).replace('T',' ').slice(0,16);
}
// ★ 반 이름 비교 전용 — 공백과 구분자(. / _ – —) 표기 차이를 흡수한다.
//   서버(Code.gs의 classKey)와 같은 규칙이라, 시트에 "3 - 1"처럼 적혀 있어도
//   "3-1" 반 과제로 이어진다. 예전에는 === 로만 비교해서 표기가 조금만 달라도
//   교사가 등록한 과제가 학생·현황판에서 통째로 빠졌다.
function classKey(v) {
  return String(v == null ? '' : v).trim()
    .replace(/\s+/g, '')
    .replace(/[.\/_–—－]/g, '-')
    .toUpperCase();
}
function sameClassName(a, b) { return classKey(a) === classKey(b); }

// ══════════════════════════════════════════════════════
// 생기부 자료용 엑셀(.xlsx) 다운로드
// - 외부 라이브러리 없이 진짜 OOXML(.xlsx) 파일을 바이트 단위로 직접 생성.
//   (예전엔 HTML 표를 .xls로 위장했는데, 실제 형식과 확장자가 달라
//    엑셀·한셀 모두 "형식과 확장명이 일치하지 않는다" 경고가 떴음.
//    진짜 .xlsx이므로 그런 경고 없이 바로 열린다.)
// ══════════════════════════════════════════════════════
function escXml(str) {
  return String(str==null?"":str)
    .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g,'')   // XML 1.0에서 허용 안 되는 제어문자 제거
    .replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;')
    .replace(/\r\n/g,'\n').replace(/\r/g,'\n');
}
function sanitizeFilePart(str) {
  return String(str==null?"":str).replace(/[\\/:*?"<>|]/g,'_').trim() || '자료';
}
const _crc32Table = (() => {
  const t = new Uint32Array(256);
  for (let n = 0; n < 256; n++) {
    let c = n;
    for (let k = 0; k < 8; k++) c = (c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1);
    t[n] = c >>> 0;
  }
  return t;
})();
function crc32(bytes) {
  let c = 0xFFFFFFFF;
  for (let i = 0; i < bytes.length; i++) c = _crc32Table[(c ^ bytes[i]) & 0xFF] ^ (c >>> 8);
  return (c ^ 0xFFFFFFFF) >>> 0;
}
// 압축 없이(store) zip 컨테이너를 직접 조립 — deflate 구현 없이도 유효한 zip이 나옴
function buildZip(files) {
  const enc = new TextEncoder();
  const localParts = [];
  const centralParts = [];
  let offset = 0;
  const dosTime = 0, dosDate = 0x21; // 임의 고정 날짜(1980-01-01), 동작에는 영향 없음
  files.forEach(f => {
    const nameBytes = enc.encode(f.name);
    const data = f.data;
    const crc = crc32(data);
    const size = data.length;

    const local = new Uint8Array(30 + nameBytes.length);
    const lv = new DataView(local.buffer);
    lv.setUint32(0, 0x04034b50, true);
    lv.setUint16(4, 20, true);
    lv.setUint16(6, 0, true);
    lv.setUint16(8, 0, true);
    lv.setUint16(10, dosTime, true);
    lv.setUint16(12, dosDate, true);
    lv.setUint32(14, crc, true);
    lv.setUint32(18, size, true);
    lv.setUint32(22, size, true);
    lv.setUint16(26, nameBytes.length, true);
    lv.setUint16(28, 0, true);
    local.set(nameBytes, 30);
    localParts.push(local, data);

    const central = new Uint8Array(46 + nameBytes.length);
    const cv = new DataView(central.buffer);
    cv.setUint32(0, 0x02014b50, true);
    cv.setUint16(4, 20, true);
    cv.setUint16(6, 20, true);
    cv.setUint16(8, 0, true);
    cv.setUint16(10, 0, true);
    cv.setUint16(12, dosTime, true);
    cv.setUint16(14, dosDate, true);
    cv.setUint32(16, crc, true);
    cv.setUint32(20, size, true);
    cv.setUint32(24, size, true);
    cv.setUint16(28, nameBytes.length, true);
    cv.setUint16(30, 0, true);
    cv.setUint16(32, 0, true);
    cv.setUint16(34, 0, true);
    cv.setUint16(36, 0, true);
    cv.setUint32(38, 0, true);
    cv.setUint32(42, offset, true);
    central.set(nameBytes, 46);
    centralParts.push(central);

    offset += local.length + data.length;
  });

  const centralSize = centralParts.reduce((a,p) => a + p.length, 0);
  const centralOffset = offset;
  const end = new Uint8Array(22);
  const ev = new DataView(end.buffer);
  ev.setUint32(0, 0x06054b50, true);
  ev.setUint16(4, 0, true);
  ev.setUint16(6, 0, true);
  ev.setUint16(8, files.length, true);
  ev.setUint16(10, files.length, true);
  ev.setUint32(12, centralSize, true);
  ev.setUint32(16, centralOffset, true);
  ev.setUint16(20, 0, true);

  return new Blob([...localParts, ...centralParts, end], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' });
}
function colLetter(i) { // 1-based 열 번호 → "A","B",...
  let s = '';
  while (i > 0) { const m = (i - 1) % 26; s = String.fromCharCode(65 + m) + s; i = Math.floor((i - 1) / 26); }
  return s;
}
// ============================================================
// XLSX용 XML 조각들 — 반드시 base64 문자열로만 보관한다.
//
// ★ 이유(중요, 건드리지 말 것):
//   구글 Apps Script는 이 HTML 파일을 서빙할 때 script 태그 안의 단순
//   문자열이라도 XML처럼 생긴 텍스트를 자기 문법이나 마크업으로
//   오해해서 코드를 망가뜨린다. 그러면 스크립트 전체가 죽어서
//   엉뚱하게도 "로그인이 안 되는" 증상으로 나타난다.
//   실제로 꺾쇠·물음표·네임스페이스 속성·중괄호를 차례로 문제 삼았고,
//   그때마다 에러가 다음 문자로 옮겨 다니며 배포본만 계속 깨졌다.
//   base64는 영문·숫자·+/= 뿐이라 Apps Script가 건드릴 것이 없다.
//
//   ⚠ 유지보수 시: 읽기 편하다고 XML을 그대로 풀어 적지 말 것.
//     값을 바꾸려면 로컬에서 XML을 만들어 base64로 변환해 교체한다.
//   로컬 파일을 브라우저로 직접 열면 멀쩡해서 배포 전엔 알 수 없다.
// ============================================================
function b64ToText(b64) {
  const bin = atob(b64);
  const bytes = new Uint8Array(bin.length);
  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
  return new TextDecoder('utf-8').decode(bytes);
}
const LT = b64ToText('PA==');   // 여는 꺾쇠 '<' 한 글자
const NL = String.fromCharCode(10);   // 줄바꿈
// 각각 [Content_Types].xml, _rels/.rels, xl/_rels/workbook.xml.rels,
// xl/workbook.xml, xl/styles.xml, 그리고 XML 선언문이다.
const XLSX_CONTENT_TYPES = b64ToText('PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9InllcyI/Pgo8VHlwZXMgeG1sbnM9Imh0dHA6Ly9zY2hlbWFzLm9wZW54bWxmb3JtYXRzLm9yZy9wYWNrYWdlLzIwMDYvY29udGVudC10eXBlcyI+PERlZmF1bHQgRXh0ZW5zaW9uPSJyZWxzIiBDb250ZW50VHlwZT0iYXBwbGljYXRpb24vdm5kLm9wZW54bWxmb3JtYXRzLXBhY2thZ2UucmVsYXRpb25zaGlwcyt4bWwiLz48RGVmYXVsdCBFeHRlbnNpb249InhtbCIgQ29udGVudFR5cGU9ImFwcGxpY2F0aW9uL3htbCIvPjxPdmVycmlkZSBQYXJ0TmFtZT0iL3hsL3dvcmtib29rLnhtbCIgQ29udGVudFR5cGU9ImFwcGxpY2F0aW9uL3ZuZC5vcGVueG1sZm9ybWF0cy1vZmZpY2Vkb2N1bWVudC5zcHJlYWRzaGVldG1sLnNoZWV0Lm1haW4reG1sIi8+PE92ZXJyaWRlIFBhcnROYW1lPSIveGwvd29ya3NoZWV0cy9zaGVldDEueG1sIiBDb250ZW50VHlwZT0iYXBwbGljYXRpb24vdm5kLm9wZW54bWxmb3JtYXRzLW9mZmljZWRvY3VtZW50LnNwcmVhZHNoZWV0bWwud29ya3NoZWV0K3htbCIvPjxPdmVycmlkZSBQYXJ0TmFtZT0iL3hsL3N0eWxlcy54bWwiIENvbnRlbnRUeXBlPSJhcHBsaWNhdGlvbi92bmQub3BlbnhtbGZvcm1hdHMtb2ZmaWNlZG9jdW1lbnQuc3ByZWFkc2hlZXRtbC5zdHlsZXMreG1sIi8+PC9UeXBlcz4=');
const XLSX_ROOT_RELS = b64ToText('PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9InllcyI/Pgo8UmVsYXRpb25zaGlwcyB4bWxucz0iaHR0cDovL3NjaGVtYXMub3BlbnhtbGZvcm1hdHMub3JnL3BhY2thZ2UvMjAwNi9yZWxhdGlvbnNoaXBzIj48UmVsYXRpb25zaGlwIElkPSJySWQxIiBUeXBlPSJodHRwOi8vc2NoZW1hcy5vcGVueG1sZm9ybWF0cy5vcmcvb2ZmaWNlRG9jdW1lbnQvMjAwNi9yZWxhdGlvbnNoaXBzL29mZmljZURvY3VtZW50IiBUYXJnZXQ9InhsL3dvcmtib29rLnhtbCIvPjwvUmVsYXRpb25zaGlwcz4=');
const XLSX_WORKBOOK_RELS = b64ToText('PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9InllcyI/Pgo8UmVsYXRpb25zaGlwcyB4bWxucz0iaHR0cDovL3NjaGVtYXMub3BlbnhtbGZvcm1hdHMub3JnL3BhY2thZ2UvMjAwNi9yZWxhdGlvbnNoaXBzIj48UmVsYXRpb25zaGlwIElkPSJySWQxIiBUeXBlPSJodHRwOi8vc2NoZW1hcy5vcGVueG1sZm9ybWF0cy5vcmcvb2ZmaWNlRG9jdW1lbnQvMjAwNi9yZWxhdGlvbnNoaXBzL3dvcmtzaGVldCIgVGFyZ2V0PSJ3b3Jrc2hlZXRzL3NoZWV0MS54bWwiLz48UmVsYXRpb25zaGlwIElkPSJySWQyIiBUeXBlPSJodHRwOi8vc2NoZW1hcy5vcGVueG1sZm9ybWF0cy5vcmcvb2ZmaWNlRG9jdW1lbnQvMjAwNi9yZWxhdGlvbnNoaXBzL3N0eWxlcyIgVGFyZ2V0PSJzdHlsZXMueG1sIi8+PC9SZWxhdGlvbnNoaXBzPg==');
const XLSX_WORKBOOK = b64ToText('PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9InllcyI/Pgo8d29ya2Jvb2sgeG1sbnM9Imh0dHA6Ly9zY2hlbWFzLm9wZW54bWxmb3JtYXRzLm9yZy9zcHJlYWRzaGVldG1sLzIwMDYvbWFpbiIgeG1sbnM6cj0iaHR0cDovL3NjaGVtYXMub3BlbnhtbGZvcm1hdHMub3JnL29mZmljZURvY3VtZW50LzIwMDYvcmVsYXRpb25zaGlwcyI+PHNoZWV0cz48c2hlZXQgbmFtZT0i7IOd6riw67aA7J6Q66OMIiBzaGVldElkPSIxIiByOmlkPSJySWQxIi8+PC9zaGVldHM+PC93b3JrYm9vaz4=');
const XLSX_STYLES = b64ToText('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');
const XML_DECL = b64ToText('PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9InllcyI/Pg==');

// 아래는 데이터에 따라 매번 달라지는 부분이라 base64로 미리 굽지 못한다.
// 대신 LT(여는 꺾쇠)를 앞에 붙여 문자열을 재조립해서,
// 소스 상에는 태그처럼 보이는 부분이 남지 않게 한다.
function xlsxCell(ref, styleIdx, text) {
  return LT + 'c r="' + ref + '" t="inlineStr" s="' + styleIdx + '">'
       + LT + 'is>' + LT + 't xml:space="preserve">' + escXml(text)
       + LT + '/t>' + LT + '/is>' + LT + '/c>';
}
// colWidths: 글자수 단위(엑셀 열 너비 단위). rows: 문자열 배열의 배열.
function buildXlsxBlob(titleLines, headers, colWidths, rows) {
  const nCols = headers.length;
  const cellRef = (r, c) => colLetter(c) + r;
  let xml = '';
  let r = 1;
  titleLines.forEach((line, i) => {
    xml += LT + 'row r="' + r + '" ht="' + (i === 0 ? 24 : 18) + '" customHeight="1">'
         + xlsxCell(cellRef(r, 1), (i === 0 ? 1 : 2), line)
         + LT + '/row>';
    r++;
  });
  const mergeCells = titleLines.map((_, i) =>
    LT + 'mergeCell ref="' + cellRef(i + 1, 1) + ':' + cellRef(i + 1, nCols) + '"/>'
  ).join('');
  xml += LT + 'row r="' + r + '" ht="6" customHeight="1"/>'; r++;
  xml += LT + 'row r="' + r + '" ht="20" customHeight="1">'
       + headers.map((h, ci) => xlsxCell(cellRef(r, ci + 1), 3, h)).join('')
       + LT + '/row>'; r++;
  rows.forEach(row => {
    xml += LT + 'row r="' + r + '" ht="90" customHeight="1">'
         + row.map((val, ci) => xlsxCell(cellRef(r, ci + 1), (ci === 0 ? 4 : 5), val)).join('')
         + LT + '/row>';
    r++;
  });
  const cols = LT + 'cols>'
    + colWidths.map((w, i) =>
        LT + 'col min="' + (i + 1) + '" max="' + (i + 1) + '" width="' + w + '" customWidth="1"/>'
      ).join('')
    + LT + '/cols>';
  const sheetXml = XML_DECL + NL
    + LT + 'worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">'
    + cols
    + LT + 'sheetData>' + xml + LT + '/sheetData>'
    + LT + 'mergeCells count="' + titleLines.length + '">' + mergeCells + LT + '/mergeCells>'
    + LT + '/worksheet>';

  const enc = new TextEncoder();
  const files = [
    { name: '[Content_Types].xml', data: enc.encode(XLSX_CONTENT_TYPES) },
    { name: '_rels/.rels', data: enc.encode(XLSX_ROOT_RELS) },
    { name: 'xl/workbook.xml', data: enc.encode(XLSX_WORKBOOK) },
    { name: 'xl/_rels/workbook.xml.rels', data: enc.encode(XLSX_WORKBOOK_RELS) },
    { name: 'xl/styles.xml', data: enc.encode(XLSX_STYLES) },
    { name: 'xl/worksheets/sheet1.xml', data: enc.encode(sheetXml) },
  ];
  return buildZip(files);
}
function saveExcelBlob(blob, filename) {
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url; a.download = filename;
  document.body.appendChild(a); a.click(); document.body.removeChild(a);
  setTimeout(() => URL.revokeObjectURL(url), 1000);
}
function todayStr() {
  const d = new Date();
  return `${d.getFullYear()}-${String(d.getMonth()+1).padStart(2,'0')}-${String(d.getDate()).padStart(2,'0')}`;
}
function selectSticker(el) {
  document.querySelectorAll('.sticker-opt').forEach(s => s.classList.remove('selected'));
  el.classList.add('selected');
  selectedSticker = el.dataset.sticker || '';
}

// ── 도장 선택 (피드백 모달) ──
function selectStamp(el) {
  setStampUI(el.dataset.stamps);
}
// 도장 버튼 상태를 n개로 맞춘다
function setStampUI(n) {
  const v = Math.max(0, Math.min(3, parseInt(n, 10) || 0));
  selectedStamps = v;
  document.querySelectorAll('.stamp-opt').forEach(el => {
    el.classList.toggle('selected', (parseInt(el.dataset.stamps, 10) || 0) === v);
  });
}
// 도장 개수를 메달 이모지로 (0개면 빈 문자열)
function stampIcons(n) {
  const v = Math.max(0, Math.min(3, parseInt(n, 10) || 0));
  return v ? '🏅'.repeat(v) : '';
}

// 모바일 사이드바
function openSidebar() {
  document.getElementById('t-sidebar').classList.add('open');
  document.getElementById('sidebar-overlay').classList.add('show');
}
function closeSidebar() {
  document.getElementById('t-sidebar').classList.remove('open');
  document.getElementById('sidebar-overlay').classList.remove('show');
}

// 파일 업로드
function handleDragOver(e, zoneId) { e.preventDefault(); document.getElementById(zoneId).classList.add('dragover'); }
function handleDragLeave(zoneId) { document.getElementById(zoneId).classList.remove('dragover'); }
function handleDrop(e, inputId, previewId, role) {
  e.preventDefault();
  // ★ previewId로 드롭존을 정확히 판별한다. 이전에는 role만 보고 판단해서
  //   과제 수정 모달에 파일을 끌어다 놓으면 하이라이트가 지워지지 않았다.
  const zoneId = previewId === 'edit-file-preview' ? 'edit-drop-zone'
               : role === 'teacher' ? 't-drop-zone' : 's-drop-zone';
  document.getElementById(zoneId).classList.remove('dragover');
  processFiles(Array.from(e.dataTransfer.files || []), previewId, role);
}
function handleFileSelect(input, previewId, role) {
  processFiles(Array.from(input.files || []), previewId, role);
  input.value = '';   // 같은 파일을 다시 골라도 change가 발생하도록 초기화
}
// ★ 여러 파일을 순서대로 업로드한다.
async function processFiles(files, previewId, role) {
  for (const f of files) await processFile(f, previewId, role);
}
// previewId로 해당 첨부 목록 배열을 돌려준다.
function getUploadList(previewId, role) {
  if (previewId === 'edit-file-preview') return editAssignUploadedFiles;
  return role === 'teacher' ? teacherUploadedFiles : studentUploadedFiles;
}
function setUploadList(previewId, role, arr) {
  if (previewId === 'edit-file-preview') editAssignUploadedFiles = arr;
  else if (role === 'teacher') teacherUploadedFiles = arr;
  else studentUploadedFiles = arr;
}
async function processFile(file, previewId, role) {
  const MAX = 50*1024*1024;
  if (file.size > MAX) { toast("❌ 파일이 50MB를 초과합니다."); return; }
  const allowed = ['image/jpeg','image/png','image/gif','image/webp','application/pdf'];
  if (!allowed.includes(file.type) && !file.type.startsWith('image/')) { toast("❌ 이미지 또는 PDF 파일만 가능합니다."); return; }
  // 수정 모달 파일인지 구분 (previewId로 판단)
  const isEditModal = previewId === 'edit-file-preview';
  const progressId = isEditModal ? 'edit-upload-progress' : (role === 'teacher' ? 't-upload-progress' : 's-upload-progress');
  document.getElementById(progressId).classList.remove('hidden');
  try {
    const base64 = await fileToBase64(file);
    const studentName = (currentStudent && currentStudent.name) ? currentStudent.name : "";
    // ★ role을 그대로 넘긴다. 이전에는 'teacher'가 하드코딩되어 있어서
    //   학생이 올린 파일까지 전부 '과제자료_교사' 폴더에 쌓였다.
    //   (과제 수정 모달은 교사 첨부이므로 role이 'teacher'로 들어온다)
    const res = await api({ action:'uploadFile', fileName:file.name, mimeType:file.type, fileData:base64, role:role, student_name:studentName });
    document.getElementById(progressId).classList.add('hidden');
    if (!res.success) { toast("❌ 업로드 실패: " + res.message); return; }
    // ★ 기존 첨부를 지우지 않고 목록에 덧붙인다 (복수 첨부)
    getUploadList(previewId, role).push({ viewUrl: res.viewUrl, fileName: res.fileName, mimeType: res.mimeType, embedUrl: res.embedUrl || '' });
    if (isEditModal) renderEditFileCurrent();
    renderFilePreview(previewId, role);
    toast("✅ " + file.name + " 업로드 완료");
  } catch(err) {
    document.getElementById(progressId).classList.add('hidden');
    toast("❌ 업로드 오류: " + err.message);
  }
}
function fileToBase64(file) {
  return new Promise((res,rej) => {
    const r = new FileReader();
    r.onload = () => res(r.result.split(',')[1]);
    r.onerror = () => rej(new Error('파일 읽기 실패'));
    r.readAsDataURL(file);
  });
}
// ★ 첨부한 파일을 모두 목록으로 그린다. (하나씩 삭제 가능)
function renderFilePreview(containerId, role) {
  const el = document.getElementById(containerId);
  if (!el) return;
  const roleKey = role || (containerId.startsWith('s-') ? 'student' : 'teacher');
  const list = getUploadList(containerId, roleKey);
  if (!list.length) { el.innerHTML = ''; return; }
  el.innerHTML = list.map(function(f, i) {
    const embed = f.embedUrl || buildEmbedUrlFromInfo(f.viewUrl, f.mimeType);
    let previewHtml = '';
    if (f.mimeType && f.mimeType.startsWith('image/')) previewHtml = `<img src="${escHtml(embed)}" alt="미리보기" onerror="this.style.display='none'">`;
    else if (f.mimeType === 'application/pdf') previewHtml = `<iframe src="${escHtml(embed)}" allowfullscreen></iframe>`;
    return `<div class="file-preview-wrap">${previewHtml}<div class="file-info-bar"><span class="file-name">📎 ${escHtml(f.fileName)}</span><a href="${escHtml(f.viewUrl)}" target="_blank" style="color:var(--accent);font-size:12px;text-decoration:none;flex-shrink:0">새창에서 보기</a><button class="btn-remove-file" onclick="removeFile('${roleKey}','${containerId}',${i})">삭제</button></div></div>`;
  }).join('');
}
function removeFile(role, previewId, index) {
  const list = getUploadList(previewId, role);
  if (typeof index === 'number') list.splice(index, 1);
  else setUploadList(previewId, role, []);
  const inputId = previewId === 'edit-file-preview' ? 'edit-file-input' : (role === 'teacher' ? 't-file-input' : 's-file-input');
  const inp = document.getElementById(inputId); if (inp) inp.value = '';
  renderFilePreview(previewId, role);
  if (previewId === 'edit-file-preview') renderEditFileCurrent();
}
// ★ 첨부 여러 개를 한 문자열로 묶는다. 파일 안은 '|||', 파일 사이는 '###'.
//   (파일이 하나뿐이면 기존 형식과 같아서 예전 데이터와 호환된다)
function packFiles(list) {
  return (list || []).map(function(f) { return [f.viewUrl, f.fileName, f.mimeType].join('|||'); }).join('###');
}
// 시트에 저장된 '###' 묶음 문자열을 파일 배열로 되돌린다.
function unpackFiles(fileUrl, fileName, mimeType) {
  const urls  = String(fileUrl  || '').split('###');
  const names = String(fileName || '').split('###');
  const mimes = String(mimeType || '').split('###');
  const out = [];
  for (let i = 0; i < urls.length; i++) {
    if (!urls[i]) continue;
    out.push({ viewUrl: urls[i], fileName: names[i] || '첨부 파일', mimeType: mimes[i] || '' });
  }
  return out;
}
function buildFileAttachHtml(fileUrl, fileName, mimeType, embedUrl) {
  if (!fileUrl) return '';
  // ★ 첨부가 여러 개('###'로 묶임)면 하나씩 나눠 그린다.
  if (String(fileUrl).indexOf('###') !== -1) {
    return unpackFiles(fileUrl, fileName, mimeType).map(function(f) {
      return buildFileAttachHtml(f.viewUrl, f.fileName, f.mimeType, buildEmbedUrlFromInfo(f.viewUrl, f.mimeType));
    }).join('');
  }
  const previewSrc = embedUrl || fileUrl;
  let previewHtml = '';
  if (mimeType && mimeType.startsWith('image/')) previewHtml = `<img src="${escHtml(previewSrc)}" alt="첨부 이미지" onerror="this.style.display='none'">`;
  else if (mimeType === 'application/pdf') previewHtml = `<iframe src="${escHtml(previewSrc)}" allowfullscreen></iframe>`;
  if (!previewHtml) {
    if (previewSrc.includes('lh3.googleusercontent')) previewHtml = `<img src="${escHtml(previewSrc)}" alt="첨부 이미지" onerror="this.style.display='none'">`;
    else if (previewSrc.includes('/preview')) previewHtml = `<iframe src="${escHtml(previewSrc)}" allowfullscreen></iframe>`;
    else {
      const ext = (fileName||'').split('.').pop().toLowerCase();
      if (['jpg','jpeg','png','gif','webp'].includes(ext)) previewHtml = `<img src="${escHtml(previewSrc)}" alt="첨부 이미지" onerror="this.style.display='none'">`;
      else if (ext === 'pdf') previewHtml = `<iframe src="${escHtml(previewSrc)}" allowfullscreen></iframe>`;
    }
  }
  return `<div class="file-attach-view"><div class="file-attach-header"><span>📎 ${escHtml(fileName||'첨부 파일')}</span><a href="${escHtml(fileUrl.replace('/preview','/view'))}" target="_blank">새창에서 보기 ↗</a></div>${previewHtml}</div>`;
}
function buildEmbedUrlFromInfo(fileUrl, mimeType) {
  if (!fileUrl) return '';
  if (fileUrl.includes('lh3.googleusercontent') || fileUrl.includes('/preview')) return fileUrl;
  const m = fileUrl.match(/\/d\/([^\/]+)/);
  if (!m) return fileUrl;
  const fileId = m[1];
  if (mimeType && mimeType.startsWith('image/')) return `https://lh3.googleusercontent.com/d/${fileId}`;
  if (mimeType === 'application/pdf') return `https://drive.google.com/file/d/${fileId}/preview`;
  return fileUrl;
}

// ── 자동 로그인: 이 기기에 학생 코드 기억하기 ──
// ★ localStorage는 Apps Script가 화면을 띄우는 googleusercontent 서브도메인에 묶여 있다.
//   구글이 그 서브도메인을 바꾸면 저장한 코드가 통째로 안 보일 수 있으므로,
//   "있으면 편하고, 없으면 평소 로그인 화면"이 되도록만 만들고 절대 여기에 기대지 않는다.
function getRememberedCode() {
  try { return String(localStorage.getItem(REMEMBER_KEY) || '').trim().toUpperCase(); } catch(e) { return ''; }
}
function setRememberedCode(code) {
  try { localStorage.setItem(REMEMBER_KEY, code); } catch(e) {}
}
function forgetRememberedCode() {
  try { localStorage.removeItem(REMEMBER_KEY); } catch(e) {}
  const box = document.getElementById("remember-code");
  if (box) box.checked = false;
}

// 로그인 성공 뒤 학생 화면으로 들어가는 공통 처리 (직접 로그인·자동 로그인이 함께 쓴다)
function enterStudentApp(student) {
  currentStudent = student;
  document.getElementById("s-name").textContent = student.name;
  document.getElementById("s-class").textContent = student.class + (student.number ? " · " + student.number : "");
  document.getElementById("s-avatar").textContent = student.name[0];
  showPage("page-student");
  loadStudentAssignments();
}

// 로그인
async function loginStudent() {
  const code = document.getElementById("student-code").value.trim();
  if (!code || code.length < 6) { toast("6자리 코드를 입력해주세요."); return; }
  showLoading("확인 중...");
  try {
    const res = await api({ action:"login", code });
    hideLoading();
    if (res.success) {
      // ★ 체크했으면 이 기기에 코드를 남기고, 체크를 풀었으면 전에 남은 것까지 지운다.
      if (document.getElementById("remember-code").checked) setRememberedCode(code.toUpperCase());
      else forgetRememberedCode();
      enterStudentApp(res.student);
    } else toast("❌ " + res.message);
  } catch(e) { hideLoading(); toast("❌ 연결 오류: " + (e.message||"")); }
}
async function loginTeacher() {
  const pw = document.getElementById("teacher-pw").value.trim();
  if (!pw) { toast("비밀번호를 입력해주세요."); return; }
  showLoading("확인 중...");
  try {
    const res = await api({ action:"teacherLogin", password:pw });
    hideLoading();
    if (res.success) {
      teacherPw = pw;
      if (res.teacherName) {
        teacherName = res.teacherName;
        const sidebarEl = document.getElementById('teacher-name-sidebar');
        if (sidebarEl) sidebarEl.textContent = '👨‍🏫 ' + res.teacherName + ' 선생님';
      }
      if (res.theme && res.theme !== '기본') applyTheme(res.theme);
      showPage("page-teacher");
      await initTeacherDashboard();
    } else toast("❌ " + res.message);
  } catch(e) { hideLoading(); toast("❌ 연결 오류: " + (e.message||"")); }
}
function logout() {
  const wasTeacher = !!teacherPw;   // 아래에서 teacherPw를 비우기 전에 기억해 둔다
  currentStudent = null; teacherPw = null;
  mySubmissions = []; allSubmissions = [];
  teacherUploadedFiles = []; studentUploadedFiles = [];
  selectedClass = null; selectedStudentCode = null;
  // ★ 교사가 워드클라우드를 켜둔 상태에서만 종료한다.
  //   이전에는 학생이 로그아웃해도 '세션 종료' 토스트가 떴다.
  if (wasTeacher && wcSession && wcSession.active) wcStopSession();
  else wcStopPolling();
  document.getElementById("student-code").value = "";
  document.getElementById("teacher-pw").value = "";
  // ★ 학생이 직접 로그아웃했다면 "이 기기에서 나가겠다"는 뜻이므로 저장된 코드도 지운다.
  //   (안 지우면 로그아웃하자마자 다시 자동 로그인돼서 빠져나올 방법이 없다.)
  forgetRememberedCode();
  showPage("page-login");
}

function switchSTab(tab, e) {
  document.querySelectorAll("#page-student .tab-btn").forEach(b => b.classList.remove("active"));
  if (e && e.currentTarget) e.currentTarget.classList.add("active");
  document.getElementById("s-tab-submit").classList.toggle("hidden", tab !== 'submit');
  document.getElementById("s-tab-my").classList.toggle("hidden", tab !== 'my');
  // ★ 과제 탭으로 돌아올 때마다 목록을 새로 받아온다.
  //   이전에는 접속 직후 딱 한 번만 불러와서, 학생이 화면을 켜 둔 사이에
  //   선생님이 새 과제를 올리면 새로고침 전까지 보이지 않았다.
  if (tab === 'submit') loadStudentAssignments();
  if (tab === 'my') loadMySubmissions();
}

async function loadStudentAssignments() {
  showLoading();
  const [aRes, sRes] = await Promise.all([
    // ★ 내 수업장소(클래스) 대상 과제 + 전체 공개 과제만 받아온다.
    //   이전에는 필터를 안 걸어서 다른 반 과제까지 전부 보였다.
    api({ action:"getAssignments", class_target:(currentStudent.class || "") }),
    api({ action:"getMySubmissions", student_code:currentStudent.code })
  ]);
  hideLoading();
  allAssignments = aRes.assignments || [];
  mySubmissions = sRes.submissions || [];
  const subMap = {};
  mySubmissions.forEach(s => {
    if (!subMap[s.assignment_id] || s.submitted_at > subMap[s.assignment_id].submitted_at) subMap[s.assignment_id] = s;
  });
  const el = document.getElementById("assignment-list");
  if (!allAssignments.length) {
    // ★ 어느 반으로 접속했는지 함께 보여준다.
    //   과제가 안 보일 때 "반이 잘못 잡혔구나"를 바로 알 수 있어야 한다.
    const cls = currentStudent && currentStudent.class ? escHtml(currentStudent.class) + ' · ' : '';
    el.innerHTML = `<div class="empty-state" style="grid-column:1/-1"><div class="icon">📋</div><p>${cls}등록된 과제가 없습니다.</p></div>`;
    return;
  }
  el.innerHTML = allAssignments.map((a,i) => {
    const sub = subMap[a.id];
    const isRejected = sub && sub.feedback && sub.feedback.is_rejected;
    const isDone = sub && !isRejected;
    let cls = 'not-submitted', statusCls = 'status-notsubmit', statusTxt = '❌ 미제출', sticker = '📄';
    if (isDone) { cls='submitted'; statusCls='status-submitted'; statusTxt='✅ 제출완료'; sticker='✅'; }
    else if (isRejected) { cls='rejected'; statusCls='status-rejected'; statusTxt='⚠️ 반려'; sticker='⚠️'; }
    const hasInfo = (a.description && String(a.description).trim()) || a.file_url;
    const infoTag = hasInfo ? `<div><span class="ap-hasinfo">📋 안내 있음</span></div>` : '';
    const dueTag  = a.due_date ? `<div style="font-size:10px;color:var(--text3);font-weight:700;margin-top:4px">마감 ${escHtml(a.due_date)}</div>` : '';
    return `<div class="a-pill ${cls}" onclick="selectAssignment('${escAttr(a.id)}')"><span class="ap-sticker">${sticker}</span><div class="ap-num">과제 ${i+1}</div><div class="ap-title">${escHtml(a.title)}</div><span class="ap-status-text ${statusCls}">${statusTxt}</span>${infoTag}${dueTag}</div>`;
  }).join('');
}

// ★ 선생님이 쓴 과제 설명을 화면에 그려주는 공통 함수
//   (이전 버전은 서버가 description을 돌려주는데도 화면에 표시하는 곳이
//    한 군데도 없어서, 선생님이 아무리 설명을 써도 학생이 볼 수 없었다)
function buildAssignmentInfoHtml(a) {
  let html = '';
  if (a.description && String(a.description).trim()) {
    html += `<div class="assign-desc-box">
      <div class="assign-desc-label">📋 과제 안내</div>
      <div class="assign-desc-body">${escHtml(a.description)}</div>
    </div>`;
  }
  if (a.due_date) {
    html += `<div class="assign-due">🗓 마감 ${escHtml(a.due_date)}</div>`;
  }
  if (a.file_url) {
    const aEmbedUrl = buildEmbedUrlFromInfo(a.file_url, a.mime_type);
    html += `<div style="font-size:12px;font-weight:800;color:var(--text2);text-transform:uppercase;letter-spacing:.5px;margin:10px 0 6px">📎 과제 안내 파일</div>${buildFileAttachHtml(a.file_url, a.file_name, a.mime_type, aEmbedUrl)}`;
  }
  return html;
}

function selectAssignment(id) {
  const subs = mySubmissions.filter(s => s.assignment_id === id).sort((a,b) => String(b.submitted_at).localeCompare(String(a.submitted_at)));
  const latest = subs[0];
  const isRejected = latest && latest.feedback && latest.feedback.is_rejected;
  const a = allAssignments.find(x => x.id === id);
  if (!a) return;

  // ★ 이미 제출했으면 수정은 막되, 과제 안내는 계속 볼 수 있게 한다.
  //   (이전 버전은 여기서 토스트만 띄우고 끝나 안내를 다시 볼 방법이 없었다)
  if (latest && !isRejected) { showAssignmentView(a, latest); return; }

  selectedAssignmentId = id;
  document.getElementById("assignment-view").classList.add("hidden");
  document.querySelectorAll(".a-pill").forEach(c => c.classList.remove("selected"));
  document.getElementById("submit-form-title").textContent = isRejected ? `🔄 ${a.title} 재제출` : `📝 ${a.title} 제출`;

  const fileViewEl = document.getElementById("assignment-file-view");
  const infoHtml = buildAssignmentInfoHtml(a);
  if (infoHtml) { fileViewEl.innerHTML = infoHtml; fileViewEl.classList.remove("hidden"); }
  else { fileViewEl.innerHTML = ''; fileViewEl.classList.add("hidden"); }

  studentUploadedFiles = [];
  document.getElementById("s-file-preview").innerHTML = '';
  const inp = document.getElementById("s-file-input");
  if (inp) inp.value = '';
  // 반려된 과제는 이전에 쓴 내용을 다시 채워줘서 고쳐 내기 편하게 한다
  document.getElementById("sub-content").value = (isRejected && latest) ? (latest.content || "") : "";
  document.getElementById("submit-form").classList.remove("hidden");
  document.getElementById("submit-form").scrollIntoView({ behavior:"smooth", block:"nearest" });
}

// ★ 이미 제출한 과제 — 읽기 전용 상세 (과제 안내 + 내가 낸 내용 + 피드백)
function showAssignmentView(a, sub) {
  document.getElementById("submit-form").classList.add("hidden");
  document.getElementById("assignment-view-title").textContent = `📋 ${a.title}`;

  const infoHtml = buildAssignmentInfoHtml(a);
  const embedUrl = buildEmbedUrlFromInfo(sub.file_url, sub.mime_type);
  const isRejected = sub.feedback && sub.feedback.is_rejected;

  let mine = `<div class="av-label">내가 제출한 내용</div>
    <div class="av-mine">${escHtml(sub.content || '(내용 없음 — 파일만 제출)')}</div>
    <div class="av-date">제출: ${fmtDate(sub.submitted_at)}</div>`;
  if (sub.file_url) mine += buildFileAttachHtml(sub.file_url, sub.file_name, sub.mime_type, embedUrl);
  if (sub.feedback) {
    mine += `<div class="feedback-box ${isRejected?'rejected-box':''}">
      <div class="fb-label ${isRejected?'rejected-label':''}">${isRejected ? '🚫 반려 사유' : '✏️ 선생님 피드백'}<span style="font-weight:400"> · ${fmtDate(sub.feedback.created_at)}</span></div>
      <div class="fb-content ${isRejected?'rejected-content':''}">${escHtml(sub.feedback.content)}</div></div>`;
  } else {
    mine += `<div class="no-feedback">아직 피드백이 없습니다.</div>`;
  }

  document.getElementById("assignment-view-body").innerHTML = infoHtml + mine;
  const el = document.getElementById("assignment-view");
  el.classList.remove("hidden");
  el.scrollIntoView({ behavior:"smooth", block:"nearest" });
}
function closeAssignmentView() {
  document.getElementById("assignment-view").classList.add("hidden");
}
function cancelSubmit() {
  selectedAssignmentId = null; studentUploadedFiles = [];
  document.getElementById("submit-form").classList.add("hidden");
  document.getElementById("s-file-preview").innerHTML = '';
}
async function submitAssignment() {
  if (!selectedAssignmentId) { toast("과제를 선택해주세요."); return; }
  const subs = mySubmissions.filter(s => s.assignment_id === selectedAssignmentId).sort((a,b) => b.submitted_at.localeCompare(a.submitted_at));
  const latest = subs[0];
  const isRejected = latest && latest.feedback && latest.feedback.is_rejected;
  if (latest && !isRejected) { toast("이미 제출한 과제입니다."); return; }
  const content = document.getElementById("sub-content").value.trim();
  let fileParam = "";
  fileParam = packFiles(studentUploadedFiles);
  // 텍스트 내용 또는 파일 첨부 중 하나는 반드시 있어야 제출 가능
  if (!content && !fileParam) { toast("내용을 입력하거나 파일을 첨부해주세요."); return; }
  if (!confirm('제출 후에는 수정이 불가합니다. 제출하시겠습니까?')) return;
  showLoading("제출 중...");
  try {
    const res = await api({ action:"submitAssignment", student_code:currentStudent.code, student_name:currentStudent.name||"", assignment_id:selectedAssignmentId, content, file_url:fileParam });
    hideLoading();
    if (res.success) { toast(isRejected ? "🔄 재제출 완료!" : "✅ 제출 완료!"); cancelSubmit(); loadStudentAssignments(); }
    else toast("❌ " + res.message);
  } catch(e) { hideLoading(); toast("오류가 발생했습니다."); }
}

async function loadMySubmissions() {
  showLoading();
  const [subRes, aRes] = await Promise.all([
    api({ action:"getMySubmissions", student_code:currentStudent.code }),
    api({ action:"getAssignments", class_target:(currentStudent.class || "") })
  ]);
  hideLoading();
  mySubmissions = subRes.submissions || [];
  renderMyStampHero(subRes);   // 제출물이 없어도 도장 요약은 보여준다
  const assignMap = {};
  (aRes.assignments||[]).forEach(a => assignMap[a.id] = a.title);
  const el = document.getElementById("my-submissions-list");
  if (!mySubmissions.length) { el.innerHTML = `<div class="empty-state"><div class="icon">📝</div><p>아직 제출한 과제가 없어요.</p></div>`; return; }
  const sorted = [...mySubmissions].sort((a,b) => b.submitted_at.localeCompare(a.submitted_at));
  el.innerHTML = sorted.map(s => {
    const isRejected = s.feedback && s.feedback.is_rejected;
    const embedUrl = buildEmbedUrlFromInfo(s.file_url, s.mime_type);
    const sticker = s.feedback && s.feedback.sticker ? s.feedback.sticker : '';
    const gotStamps = s.feedback && !isRejected ? stampIcons(s.feedback.stamps) : '';
    return `<div class="card"><div class="card-header"><div><div class="card-title">${sticker ? sticker+' ' : ''}${escHtml(assignMap[s.assignment_id]||s.assignment_id)}</div><div class="card-meta">제출: ${fmtDate(s.submitted_at)}</div></div>${gotStamps ? `<span class="chip" style="background:#fdf0ea;color:var(--accent2)">${gotStamps} 도장 ${s.feedback.stamps}개</span>` : ''}${isRejected ? '<span class="chip chip-orange">⚠️ 반려 — 재제출 필요</span>' : s.feedback ? '<span class="chip chip-green">✅ 피드백 있음</span>' : '<span class="chip chip-gray">피드백 대기</span>'}</div><div class="card-body">${escHtml(s.content)}</div>${s.file_url ? buildFileAttachHtml(s.file_url, s.file_name, s.mime_type, embedUrl) : ''}${s.feedback ? `<div class="feedback-box ${isRejected?'rejected-box':''}"><div class="fb-label ${isRejected?'rejected-label':''}">${isRejected ? '🚫 반려 사유' : '✏️ 선생님 피드백'}<span style="font-weight:400"> · ${fmtDate(s.feedback.created_at)}</span></div><div class="fb-content ${isRejected?'rejected-content':''}">${escHtml(s.feedback.content)}</div></div>` : `<div class="no-feedback">아직 피드백이 없습니다.</div>`}</div>`;
  }).join('');
}

// 교사 초기화
async function initTeacherDashboard() {
  showLoading("데이터 불러오는 중...");
  try {
    const [aRes, sRes, cRes] = await Promise.all([
      api({ action:"getAssignments" }),
      api({ action:"getStudents", password:teacherPw }),
      api({ action:"getClasses", password:teacherPw })
    ]);
    allAssignments = aRes.assignments || [];
    allStudents = sRes.students || [];
    allClasses = cRes.classes || [];
    const classNames = new Set(allClasses.map(c => c.name));
    const studentClasses = [...new Set(allStudents.map(s => s.class))];
    studentClasses.forEach(sc => {
      if (sc && !classNames.has(sc)) allClasses.push({ id:'auto_'+sc, name:sc, created_at:'' });
    });
    renderSidebarClassList();
    populateClassSelect();
    enteredClass = null;
    document.getElementById('t-sidebar-menu').classList.add('hidden');
    document.getElementById('entered-class-banner').classList.add('hidden');
    document.getElementById('t-topbar-title').textContent = '클래스를 선택하세요';
    document.querySelectorAll('.t-panel').forEach(p => p.classList.remove('active'));
    document.getElementById('panel-students').classList.add('active');
    document.getElementById('student-cards-view').classList.remove('hidden');
    document.getElementById('student-detail-view').classList.add('hidden');
    document.getElementById('selected-class-title').textContent = '클래스를 선택하세요';
    document.getElementById('overview-stats').innerHTML = '';
    document.getElementById('student-card-grid').innerHTML = `<div class="empty-state" style="grid-column:1/-1"><div class="icon">👈</div><p>왼쪽에서 클래스를 선택하세요</p></div>`;
  } finally { hideLoading(); }
}

function renderSidebarClassList() {
  const sidebarList = document.getElementById('sidebar-class-list');
  const colors = ['#e74c3c','#3498db','#2ecc71','#f39c12','#9b59b6','#1abc9c','#e67e22'];
  sidebarList.innerHTML = allClasses.map((c,i) => {
    const col = colors[i % colors.length];
    // ★ 학생 명단에서 자동으로 만들어낸 임시 클래스(auto_)는 클래스목록 시트에 없으므로
    //   수정·삭제 버튼을 달지 않는다. 서버에서 찾지 못해 오류가 난다.
    const isReal = !String(c.id).startsWith('auto_');
    const actions = isReal
      ? `<span class="cc-actions">
           <button class="cc-btn" title="이름 수정" onclick="event.stopPropagation();openRenameClassModal('${escAttr(c.id)}')">✏️</button>
           <button class="cc-btn" title="삭제" onclick="event.stopPropagation();confirmDeleteClass('${escAttr(c.id)}')">🗑</button>
         </span>`
      : '';
    return `<div class="class-chip" onclick="enterClass('${escAttr(c.name)}', this)"><span class="cc-dot" style="background:${col}"></span><span class="cc-name">${escHtml(c.name)}</span>${actions}</div>`;
  }).join('');
}
function populateClassSelect(extraId) {
  const sel = document.getElementById('new-a-class');
  if (sel) sel.innerHTML = '<option value="">전체 공개</option>' + allClasses.map(c => `<option value="${escHtml(c.name)}">${escHtml(c.name)}</option>`).join('');
  const ssel = document.getElementById('new-s-class');
  if (ssel) ssel.innerHTML = '<option value="">클래스 선택</option>' + allClasses.map(c => `<option value="${escHtml(c.name)}">${escHtml(c.name)}</option>`).join('');
  if (extraId) {
    const esel = document.getElementById(extraId);
    if (esel) esel.innerHTML = '<option value="">클래스 선택</option>' + allClasses.map(c => `<option value="${escHtml(c.name)}">${escHtml(c.name)}</option>`).join('');
  }
}

async function enterClass(className, el) {
  enteredClass = className; selectedClass = className;
  document.querySelectorAll('.class-chip').forEach(c => c.classList.remove('active'));
  if (el) el.classList.add('active');
  document.getElementById('entered-class-banner').classList.remove('hidden');
  document.getElementById('entered-class-name').textContent = className;
  document.getElementById('t-sidebar-menu').classList.remove('hidden');
  showTeacherPanel('students');
  await loadStudentCardsForClass(className);
}
function exitClass() {
  enteredClass = null; selectedClass = null;
  document.querySelectorAll('.class-chip').forEach(c => c.classList.remove('active'));
  document.getElementById('entered-class-banner').classList.add('hidden');
  document.getElementById('t-sidebar-menu').classList.add('hidden');
  document.getElementById('t-topbar-title').textContent = '클래스를 선택하세요';
  document.querySelectorAll('.t-panel').forEach(p => p.classList.remove('active'));
  document.getElementById('panel-students').classList.add('active');
  document.getElementById('student-card-grid').innerHTML = `<div class="empty-state" style="grid-column:1/-1"><div class="icon">👈</div><p>왼쪽에서 클래스를 선택하세요</p></div>`;
  document.getElementById('selected-class-title').textContent = '클래스를 선택하세요';
  document.getElementById('overview-stats').innerHTML = '';
  stampBoard = null;
  document.getElementById('stamp-board').innerHTML = `<div class="empty-state"><div class="icon">🏅</div><p>클래스를 선택하면 표시됩니다.</p></div>`;
}

function showTeacherPanel(name) {
  document.querySelectorAll('.t-panel').forEach(p => p.classList.remove('active'));
  document.querySelectorAll('.menu-item').forEach(m => m.classList.remove('active'));
  document.getElementById(`panel-${name}`).classList.add('active');
  const menuMap = { 'students':'menu-students', 'assignments':'menu-assignments', 'matrix':'menu-matrix', 'stamps':'menu-stamps', 'manage-assign':'menu-manage-assign', 'manage-students':'menu-manage-students' };
  if (menuMap[name]) document.getElementById(menuMap[name]).classList.add('active');
  if (name === 'wordcloud') document.getElementById('wc-menu-btn').classList.add('active');
  else document.getElementById('wc-menu-btn').classList.remove('active');
  const titleMap = { 'students':'학생별 보기', 'assignments':'과제별 보기', 'matrix':'현황판', 'stamps':'🏅 도장 · 학급공약', 'manage-assign':'과제 관리', 'manage-students':'학생 관리', 'wordcloud':'☁️ 워드클라우드' };
  document.getElementById('t-topbar-title').textContent = (enteredClass && name !== 'wordcloud' ? enteredClass + ' — ' : '') + (titleMap[name] || '');
  if (name === 'assignments') loadAssignmentCardsView();
  if (name === 'matrix') loadMatrixView();
  if (name === 'stamps') loadStampBoard();
  if (name === 'manage-assign') loadTeacherAssignmentList();
  if (name === 'manage-students') loadStudents();
}

async function loadStudentCardsForClass(className) {
  showLoading();
  try {
    const classStudents = allStudents.filter(s => sameClassName(s.class, className));
    const res = await api({ action:"getAllSubmissions", password:teacherPw, assignment_id:"", student_code:"" });
    allSubmissions = res.submissions || [];
    hideLoading();
    const subMap = {};
    const rejectMap = {};
    allSubmissions.forEach(s => {
      if (!subMap[s.student_code]) subMap[s.student_code] = 0; subMap[s.student_code]++;
      if (s.feedback && s.feedback.is_rejected) rejectMap[s.student_code] = (rejectMap[s.student_code] || 0) + 1;
    });
    document.getElementById("selected-class-title").textContent = className;
    const total = classStudents.length;
    const submitted = classStudents.filter(s => (subMap[s.code]||0) > 0).length;
    // 반려된 과제가 하나라도 있는 학생 수 (있을 때만 칩으로 보여 준다)
    const rejected = classStudents.filter(s => (rejectMap[s.code]||0) > 0).length;
    document.getElementById("overview-stats").innerHTML = `<span class="stat-badge" style="background:var(--submitted-bg);color:var(--submitted-text)">✅ 제출 ${submitted}명</span><span class="stat-badge" style="background:var(--notsubmit-bg);color:var(--notsubmit-text)">❌ 미제출 ${total-submitted}명</span>` + (rejected ? `<span class="stat-badge" style="background:var(--rejected-bg);color:var(--rejected-text)">⚠️ 반려 ${rejected}명</span>` : '');
    document.getElementById("student-detail-view").classList.add("hidden");
    document.getElementById("student-cards-view").classList.remove("hidden");
    const grid = document.getElementById("student-card-grid");
    if (!classStudents.length) { grid.innerHTML = `<div class="empty-state" style="grid-column:1/-1"><div class="icon">👤</div><p>등록된 학생이 없습니다.</p></div>`; return; }
    const sorted = [...classStudents].sort((a,b) => String(a.number).localeCompare(String(b.number)));
    grid.innerHTML = sorted.map(s => {
      const cnt = subMap[s.code] || 0;
      const hasSub = cnt > 0;
      return `<div class="student-card ${hasSub?'submitted':'not-submitted'}" onclick="openStudentDetail('${escAttr(s.code)}')"><span class="sc-sticker">${hasSub?'⭐':'📄'}</span><div class="sc-name">${escHtml(s.name)}</div><div class="sc-number">${escHtml(s.number||'')}</div><span class="sc-count ${hasSub?'done':'none'}">${hasSub ? `📋 ${cnt}건` : '미제출'}</span></div>`;
    }).join('');
  } catch(e) { hideLoading(); toast("❌ 오류: " + e.message); }
}

async function openStudentDetail(studentCode) {
  const student = allStudents.find(s => s.code === studentCode);
  if (!student) return;
  selectedStudentCode = studentCode;
  showLoading();
  try {
    const res = await api({ action:"getAllSubmissions", password:teacherPw, student_code:studentCode });
    hideLoading();
    const subs = res.submissions || [];
    const subMap = {};
    subs.forEach(s => { if (!subMap[s.assignment_id] || s.submitted_at > subMap[s.assignment_id].submitted_at) subMap[s.assignment_id] = s; });
    document.getElementById("student-cards-view").classList.add("hidden");
    document.getElementById("student-detail-view").classList.remove("hidden");
    document.getElementById("student-detail-title").textContent = `${student.name} (${student.number||''})`;
    const grid = document.getElementById("student-assignment-grid");
    // ★ 입장한 클래스 대상 과제만 보여준다 (전체 공개 과제 포함).
    //   이전에는 필터 없이 전체를 보여줘서 현황판과 과제 개수가 서로 달랐다.
    const viewAssignments = allAssignments.filter(a => !enteredClass || !a.class_target || sameClassName(a.class_target, enteredClass));
    studentDetailExportData = { student, submitted: [] };
    if (!viewAssignments.length) { grid.innerHTML = `<div class="empty-state" style="grid-column:1/-1"><div class="icon">📋</div><p>등록된 과제가 없습니다.</p></div>`; return; }
    grid.innerHTML = viewAssignments.map((a,i) => {
      const sub = subMap[a.id];
      const isRejected = sub && sub.feedback && sub.feedback.is_rejected;
      const isDone = sub && !isRejected;
      let cls = 'not-submitted', sticker = '📄', statusTxt = '미제출', statusCls = 'status-notsubmit';
      if (isDone) { cls='submitted'; sticker='✅'; statusTxt='제출완료'; statusCls='status-submitted'; studentDetailExportData.submitted.push({ assignment:a, sub }); }
      else if (isRejected) { cls='rejected'; sticker='⚠️'; statusTxt='반려'; statusCls='status-rejected'; }
      return `<div class="a-pill ${cls}" onclick="openSubmissionModal('${escAttr(sub ? sub.id : '')}','${escAttr(studentCode)}','${escAttr(a.id)}','${escAttr(student.name)}','${escAttr(a.title)}')"><span class="ap-sticker">${sticker}</span><div class="ap-num">과제 ${i+1}</div><div class="ap-title">${escHtml(a.title)}</div><span class="ap-status-text ${statusCls}">${statusTxt}</span>${sub ? `<div style="font-size:10px;color:var(--text3);margin-top:4px;font-weight:700">${fmtDate(sub.submitted_at)}</div>` : ''}</div>`;
    }).join('');
  } catch(e) { hideLoading(); toast("❌ 오류: " + e.message); }
}
function downloadStudentExcel() {
  const data = studentDetailExportData;
  if (!data) return;
  if (!data.submitted.length) { toast("제출한 과제가 없습니다."); return; }
  const { student, submitted } = data;
  const rows = submitted.map((item, i) => {
    const fb = item.sub.feedback && !item.sub.feedback.is_rejected ? item.sub.feedback.content : '';
    return [String(i+1), item.assignment.title, fmtDate(item.sub.submitted_at), item.sub.content || '', fb];
  });
  const titleLines = [
    `${student.name} 학생 제출 활동 정리 (생활기록부 참고자료)`,
    `${student.class||''} ${student.number||''}번 · 제출 ${submitted.length}건 · 생성일 ${todayStr()}`
  ];
  const blob = buildXlsxBlob(
    titleLines,
    ['번호','과제명','제출일','제출 내용','교사 피드백'],
    [6,28,16,55,34],
    rows
  );
  saveExcelBlob(blob, `${sanitizeFilePart(student.name)}_생기부자료_${todayStr()}.xlsx`);
}
function backToStudentCards() {
  document.getElementById("student-detail-view").classList.add("hidden");
  document.getElementById("student-cards-view").classList.remove("hidden");
}

async function loadAssignmentCardsView() {
  const grid = document.getElementById("assignment-card-grid");
  if (!allAssignments.length) { grid.innerHTML = `<div class="empty-state" style="grid-column:1/-1"><div class="icon">📋</div><p>등록된 과제가 없습니다.</p></div>`; return; }
  showLoading();
  try {
    const res = await api({ action:"getAllSubmissions", password:teacherPw });
    allSubmissions = res.submissions || [];
    hideLoading();
    const countMap = {};
    allSubmissions.forEach(s => { if (!countMap[s.assignment_id]) countMap[s.assignment_id] = 0; countMap[s.assignment_id]++; });
    document.getElementById("assignment-cards-view").classList.remove("hidden");
    document.getElementById("assignment-detail-view").classList.add("hidden");
    grid.innerHTML = allAssignments.map((a,i) => {
      const cnt = countMap[a.id] || 0;
      return `<div class="assignment-card ${cnt>0?'has-new':''}" onclick="openAssignmentDetail('${escAttr(a.id)}')"><span class="ac-icon">📋</span><span class="ac-badge ${cnt>0?'green':'red'}">${cnt}건</span><div class="ac-title">${escHtml(a.title)}</div><div class="ac-meta">${a.due_date ? '마감 '+a.due_date : '마감 없음'}${a.class_target?' · '+escHtml(a.class_target):''}</div></div>`;
    }).join('');
  } catch(e) { hideLoading(); toast("❌ 오류: " + e.message); }
}

let teacherDetailAssignId = null;   // 교사 '과제별 보기'에서 열어둔 과제 (갱신용)
async function openAssignmentDetail(assignmentId) {
  const assignment = allAssignments.find(a => a.id === assignmentId);
  if (!assignment) return;
  teacherDetailAssignId = assignmentId;
  showLoading();
  try {
    const res = await api({ action:"getAllSubmissions", password:teacherPw, assignment_id:assignmentId });
    hideLoading();
    const subs = res.submissions || [];
    const subMap = {};
    subs.forEach(s => { subMap[s.student_code] = s; });
    document.getElementById("assignment-cards-view").classList.add("hidden");
    document.getElementById("assignment-detail-view").classList.remove("hidden");
    document.getElementById("assignment-detail-title").textContent = assignment.title;
    const classFilter = enteredClass || assignment.class_target || null;
    const targetStudents = classFilter ? allStudents.filter(s => sameClassName(s.class, classFilter)) : allStudents;
    // 이 과제는 학생당 제출물이 하나라서 제출·반려·미제출이 서로 겹치지 않는다.
    // (아래 카드 상태와 숫자가 정확히 맞아떨어지도록 반려는 제출에서 빼고 따로 센다)
    const targetCodes = new Set(targetStudents.map(t => t.code));
    const targetSubs  = subs.filter(s => targetCodes.has(s.student_code));
    const rejected  = targetSubs.filter(s => s.feedback && s.feedback.is_rejected).length;
    const submitted = targetSubs.length - rejected;
    const total = targetStudents.length;
    document.getElementById("assignment-stats").innerHTML = `<span class="stat-badge" style="background:var(--submitted-bg);color:var(--submitted-text)">✅ 제출 ${submitted}명</span><span class="stat-badge" style="background:var(--notsubmit-bg);color:var(--notsubmit-text)">❌ 미제출 ${total-targetSubs.length}명</span>` + (rejected ? `<span class="stat-badge" style="background:var(--rejected-bg);color:var(--rejected-text)">⚠️ 반려 ${rejected}명</span>` : '');
    const sorted = [...targetStudents].sort((a,b) => String(a.number).localeCompare(String(b.number)));
    const grid = document.getElementById("assignment-student-grid");
    assignmentDetailExportData = { assignment, submitted: [] };
    grid.innerHTML = sorted.map(s => {
      const sub = subMap[s.code];
      const isRejected = sub && sub.feedback && sub.feedback.is_rejected;
      const isDone = sub && !isRejected;
      const hasFeedback = sub && sub.feedback && !sub.feedback.is_rejected;
      let cls = 'not-submitted', sticker = '📄', statusTxt = '미제출', statusBg = 'var(--notsubmit)', statusColor = 'var(--notsubmit-text)';
      if (isDone && hasFeedback) { cls='submitted'; sticker='⭐'; statusTxt='완료'; statusBg='var(--submitted)'; statusColor='var(--submitted-text)'; assignmentDetailExportData.submitted.push({ student:s, sub }); }
      else if (isDone) { cls='submitted'; sticker='✅'; statusTxt='확인전'; statusBg='var(--submitted)'; statusColor='var(--submitted-text)'; assignmentDetailExportData.submitted.push({ student:s, sub }); }
      else if (isRejected) { sticker='⚠️'; statusTxt='반려'; statusBg='var(--rejected)'; statusColor='var(--rejected-text)'; }
      return `<div class="submission-card ${cls}" onclick="openSubmissionModal('${escAttr(sub?sub.id:'')}','${escAttr(s.code)}','${escAttr(assignmentId)}','${escAttr(s.name)}','${escAttr(assignment.title)}')"><span class="sc2-sticker">${sticker}</span><div class="sc2-name">${escHtml(s.name)}</div><span class="sc2-status" style="background:${statusBg};color:${statusColor}">${statusTxt}</span>${sub ? `<div class="sc2-date">${fmtDate(sub.submitted_at)}</div>` : ''}</div>`;
    }).join('');
  } catch(e) { hideLoading(); toast("❌ 오류: " + e.message); }
}
function downloadAssignmentExcel() {
  const data = assignmentDetailExportData;
  if (!data) return;
  if (!data.submitted.length) { toast("제출한 학생이 없습니다."); return; }
  const { assignment, submitted } = data;
  const sorted = [...submitted].sort((a,b) => String(a.student.number).localeCompare(String(b.student.number)));
  const rows = sorted.map((item, i) => {
    const fb = item.sub.feedback && !item.sub.feedback.is_rejected ? item.sub.feedback.content : '';
    return [String(i+1), item.student.name, item.student.number||'', fmtDate(item.sub.submitted_at), item.sub.content || '', fb];
  });
  const titleLines = [
    `[${assignment.title}] 제출 학생 활동 정리 (생활기록부 참고자료)`,
    `${assignment.class_target||'전체'} · 제출 ${submitted.length}명 · 생성일 ${todayStr()}`
  ];
  const blob = buildXlsxBlob(
    titleLines,
    ['번호','이름','학번','제출일','제출 내용','교사 피드백'],
    [6,12,10,16,50,34],
    rows
  );
  saveExcelBlob(blob, `${sanitizeFilePart(assignment.title)}_생기부자료_${todayStr()}.xlsx`);
}
function backToAssignmentCards() {
  document.getElementById("assignment-detail-view").classList.add("hidden");
  document.getElementById("assignment-cards-view").classList.remove("hidden");
}

async function openSubmissionModal(subId, studentCode, assignmentId, studentName, assignmentTitle) {
  modalSubId = subId || null; modalStudentCode = studentCode; modalAssignmentId = assignmentId;
  selectedSticker = '⭐';
  document.querySelectorAll('.sticker-opt').forEach(s => s.classList.remove('selected'));
  document.querySelector('.sticker-opt[data-sticker="⭐"]')?.classList.add('selected');
  setStampUI(0);
  document.getElementById("modal-title").textContent = `${studentName} · ${assignmentTitle}`;
  document.getElementById("modal-fb-input").value = '';
  document.getElementById("modal-existing-feedback").innerHTML = '';
  document.getElementById("modal-file-view").innerHTML = '';
  document.getElementById("modal-content").textContent = '';
  document.getElementById("modal-meta").textContent = '';
  showLoading();
  try {
    const res = await api({ action:"getAllSubmissions", password:teacherPw, student_code:studentCode, assignment_id:assignmentId });
    hideLoading();
    const subs = res.submissions || [];
    // ★ 반드시 이 학생의 제출물만 본다.
    //   예전에는 못 찾으면 목록의 첫 제출물(다른 학생 것)을 그대로 띄웠고,
    //   거기에 쓴 피드백은 클릭한 학생 앞으로 저장돼 아무도 못 보는 상태가 됐다.
    const mine = studentCode
      ? subs.filter(s => String(s.student_code || '').toUpperCase() === String(studentCode).toUpperCase())
      : subs;
    const sub = (subId && mine.find(s => s.id === subId)) || mine[0];
    if (!sub) {
      modalSubId = null;   // 저장 버튼이 엉뚱한 행을 가리키지 않게 비운다
      document.getElementById("modal-content").textContent = '아직 제출하지 않은 과제입니다.';
      document.getElementById("submission-modal").classList.remove("hidden");
      return;
    }
    document.getElementById("modal-meta").textContent = `제출: ${fmtDate(sub.submitted_at)}`;
    document.getElementById("modal-content").textContent = sub.content || '';
    if (sub.id) modalSubId = sub.id;
    const embedUrl = buildEmbedUrlFromInfo(sub.file_url, sub.mime_type);
    if (sub.file_url) document.getElementById("modal-file-view").innerHTML = buildFileAttachHtml(sub.file_url, sub.file_name, sub.mime_type, embedUrl);
    if (sub.feedback) {
      const isRejected = sub.feedback.is_rejected;
      document.getElementById("modal-existing-feedback").innerHTML = `<div class="feedback-saved" style="${isRejected?'background:var(--notsubmit-bg);border-color:var(--notsubmit);color:var(--notsubmit-text)':''}">${isRejected?'🚫 반려됨':'✏️ 기존 피드백'}: ${escHtml(sub.feedback.content)}</div>`;
      document.getElementById("modal-fb-input").value = isRejected ? '' : sub.feedback.content;
      // 반려된 건은 도장이 회수된 상태이므로 0에서 다시 시작한다
      setStampUI(isRejected ? 0 : (sub.feedback.stamps || 0));
    }
  } catch(e) { hideLoading(); toast("❌ 오류: " + e.message); }
  document.getElementById("submission-modal").classList.remove("hidden");
}
function closeModal() {
  document.getElementById("submission-modal").classList.add("hidden");
  modalSubId = null; modalStudentCode = null; modalAssignmentId = null;
}
async function doSaveFeedback() {
  if (!modalSubId) { toast("제출물이 없습니다."); return; }
  const content = document.getElementById("modal-fb-input").value.trim();
  if (!content) { toast("피드백 내용을 입력해주세요."); return; }
  const finalContent = selectedSticker ? `${selectedSticker} ${content}` : content;
  showLoading("저장 중...");
  const res = await api({ action:"submitFeedback", password:teacherPw, submission_id:modalSubId, student_code:modalStudentCode, assignment_id:modalAssignmentId, content:finalContent, stamps:selectedStamps });
  hideLoading();
  if (res.success) {
    toast("✅ " + (res.message || "피드백이 저장되었습니다.")); closeModal();
    // 도장 현황판을 보고 있었다면 숫자가 바로 반영되게 다시 불러온다
    if (document.getElementById("panel-stamps").classList.contains("active")) { loadStampBoard(); return; }
    if (!document.getElementById("panel-assignments").classList.contains("active")) { if (selectedClass) loadStudentCardsForClass(selectedClass); } else loadAssignmentCardsView();
  } else toast("❌ " + res.message);
}
async function doRejectSubmission() {
  if (!modalSubId) { toast("제출물이 없습니다."); return; }
  if (!confirm("이 제출물을 반려하시겠습니까?")) return;
  showLoading("반려 처리 중...");
  const res = await api({ action:"rejectSubmission", password:teacherPw, submission_id:modalSubId, student_code:modalStudentCode, assignment_id:modalAssignmentId });
  hideLoading();
  if (res.success) {
    toast("🚫 반려 처리되었습니다.");
    closeModal();
    // ★ 화면 갱신 — 이전에는 갱신을 안 해서 반려했는데도 '제출완료'로 남아 보였다
    if (document.getElementById("panel-stamps").classList.contains("active")) {
      loadStampBoard();   // 반려하면 그 과제 도장도 회수되므로 집계를 다시 읽는다
    } else if (document.getElementById("panel-assignments").classList.contains("active")) {
      if (teacherDetailAssignId && !document.getElementById("assignment-detail-view").classList.contains("hidden"))
        openAssignmentDetail(teacherDetailAssignId);
      else loadAssignmentCardsView();
    } else if (document.getElementById("panel-matrix").classList.contains("active")) {
      loadMatrixView();
    } else if (selectedStudentCode && !document.getElementById("student-detail-view").classList.contains("hidden")) {
      openStudentDetail(selectedStudentCode);
    } else if (selectedClass) {
      loadStudentCardsForClass(selectedClass);
    }
  } else toast("❌ " + res.message);
}

async function loadStudents() {
  showLoading();
  const res = await api({ action:"getStudents", password:teacherPw });
  hideLoading();
  allStudents = res.students || [];
  renderStudentTable(allStudents);
  buildClassFilterButtons();
}
function buildClassFilterButtons() {
  const classes = [...new Set(allStudents.map(s => s.class))].sort();
  document.getElementById("student-class-filter").innerHTML = `<button class="chip chip-blue" onclick="filterStudentsByClass('all',this)" style="cursor:pointer">전체</button>` + classes.map(c => `<button class="chip chip-gray" onclick="filterStudentsByClass('${escAttr(c)}',this)" style="cursor:pointer">${escHtml(c)}</button>`).join('');
}
function filterStudentsByClass(cls, btn) {
  currentClassFilter = cls;
  document.querySelectorAll("#student-class-filter .chip").forEach(b => { b.classList.remove("chip-blue"); b.classList.add("chip-gray"); });
  if (btn) { btn.classList.remove("chip-gray"); btn.classList.add("chip-blue"); }
  renderStudentTable(cls === 'all' ? allStudents : allStudents.filter(s => sameClassName(s.class, cls)));
}
// 학생 목록 한 줄. 목록 그리기와 정렬 두 곳에서 같은 모양을 써야 해서 함수로 뺐다.
function studentRowHtml(s) {
  return `<tr><td><span class="code-badge">${s.code}</span></td><td style="font-weight:800">${escHtml(s.name)}</td><td>${escHtml(s.class)}</td><td style="color:var(--text3)">${escHtml(s.number||'')}</td><td><button class="btn-edit-assign" title="학생명 수정" onclick="openRenameStudentModal('${escAttr(s.code)}')">✏️ 수정</button></td></tr>`;
}
function renderStudentTable(students) {
  const tbody = document.getElementById("student-tbody");
  if (!students.length) { tbody.innerHTML = `<tr><td colspan="5" style="text-align:center;color:var(--text3);padding:30px">등록된 학생이 없습니다.</td></tr>`; return; }
  tbody.innerHTML = [...students].sort((a,b) => a.class.localeCompare(b.class,'ko') || String(a.number).localeCompare(String(b.number),'ko')).map(studentRowHtml).join('');
}
function sortStudentTable(col) {
  _tableSortDir[col] = !_tableSortDir[col];
  const asc = _tableSortDir[col];
  const keys = ['code','name','class','number'];
  const key = keys[col];
  const base = currentClassFilter === 'all' ? allStudents : allStudents.filter(s => sameClassName(s.class, currentClassFilter));
  document.getElementById("student-tbody").innerHTML = [...base].sort((a,b) => { const va = String(a[key]||''), vb = String(b[key]||''); return asc ? va.localeCompare(vb,'ko') : vb.localeCompare(va,'ko'); }).map(studentRowHtml).join('');
}

// ── 학생명 수정 ──
let renamingStudentCode = null;
function openRenameStudentModal(code) {
  const s = allStudents.find(x => String(x.code) === String(code));
  if (!s) return;
  renamingStudentCode = code;
  document.getElementById('rename-student-hint').textContent =
    `${s.class}${s.number ? ' · ' + s.number : ''} · 코드 ${s.code} — 지금까지 낸 제출물과 피드백의 이름도 함께 바뀝니다.`;
  const input = document.getElementById('rename-student-name');
  input.value = s.name;
  document.getElementById('rename-student-modal').classList.remove('hidden');
  input.focus();
  input.select();
}
function closeRenameStudentModal() {
  document.getElementById('rename-student-modal').classList.add('hidden');
  renamingStudentCode = null;
}
async function submitRenameStudent() {
  if (!renamingStudentCode) return;
  const code = renamingStudentCode;
  const s = allStudents.find(x => String(x.code) === String(code));
  const newName = document.getElementById('rename-student-name').value.trim();
  if (!newName) { toast('이름을 입력해주세요.'); return; }
  if (s && s.name === newName) { closeRenameStudentModal(); return; }
  showLoading('변경 중...');
  const res = await api({ action:'renameStudent', password:teacherPw, code, new_name:newName });
  hideLoading();
  if (!res.success) { toast('❌ ' + res.message); return; }
  toast('✅ ' + res.message);
  closeRenameStudentModal();
  if (s) s.name = res.name || newName;
  // ★ 학생 이름은 학생 카드·현황판·제출물 목록에도 그려져 있으므로 보고 있는 화면을 다시 그린다.
  renderStudentTable(currentClassFilter === 'all' ? allStudents : allStudents.filter(x => x.class === currentClassFilter));
  await refreshAfterStudentRename();
}
// 이름이 바뀐 뒤, 열려 있는 다른 화면의 옛 이름을 지운다.
async function refreshAfterStudentRename() {
  try {
    if (document.getElementById('panel-matrix').classList.contains('active')) { loadMatrixView(); return; }
    if (document.getElementById('panel-assignments').classList.contains('active')) {
      if (teacherDetailAssignId && !document.getElementById('assignment-detail-view').classList.contains('hidden'))
        openAssignmentDetail(teacherDetailAssignId);
      else loadAssignmentCardsView();
      return;
    }
    if (selectedStudentCode && !document.getElementById('student-detail-view').classList.contains('hidden')) {
      openStudentDetail(selectedStudentCode);
      return;
    }
    if (selectedClass) loadStudentCardsForClass(selectedClass);
  } catch(e) {}
}
function showAddStudentForm() {
  populateClassSelect();
  if (enteredClass) { const ssel = document.getElementById('new-s-class'); if (ssel) ssel.value = enteredClass; }
  document.getElementById("add-student-form").classList.remove("hidden");
}
function hideAddStudentForm() { document.getElementById("add-student-form").classList.add("hidden"); }
function showBulkAddModal() {
  populateClassSelect('bulk-s-class');
  if (enteredClass) { const sel = document.getElementById('bulk-s-class'); if (sel) sel.value = enteredClass; }
  document.getElementById('bulk-s-list').value = '';
  document.getElementById('bulk-preview').textContent = '';
  document.getElementById('bulk-add-modal').classList.remove('hidden');
  document.getElementById('bulk-s-list').focus();
}
function closeBulkAddModal() { document.getElementById('bulk-add-modal').classList.add('hidden'); }
function parseBulkList(raw) {
  return raw.split('\n').map(line => line.trim()).filter(line => line.length > 0).map(line => {
    const parts = line.split(/\s+/);
    if (parts.length === 1) return { number: '', name: parts[0] };
    if (/^\d+$/.test(parts[0])) return { number: parts[0], name: parts.slice(1).join(' ') };
    return { number: '', name: parts.join(' ') };
  }).filter(s => s.name);
}
async function doBulkAddStudents() {
  const cls = document.getElementById('bulk-s-class').value.trim();
  const raw = document.getElementById('bulk-s-list').value;
  if (!cls) { toast('클래스를 선택해주세요.'); return; }
  const students = parseBulkList(raw);
  if (!students.length) { toast('학생 정보를 입력해주세요.'); return; }
  // ★ 서버로 한 번에 보낸다. 이전에는 1명당 1회씩 왕복해서
  //   30명 등록에 수십 초가 걸렸다 (bulkAddStudents는 있는데 안 쓰고 있었다).
  showLoading(`${students.length}명 등록 중...`);
  try {
    const res = await api({ action:'bulkAddStudents', password:teacherPw, class_name:cls, students_json:JSON.stringify(students) });
    hideLoading(); closeBulkAddModal();
    if (!res.success) { toast('❌ ' + res.message); return; }
    toast(`✅ ${res.count}명 등록 완료`);
    loadStudents();
    const codes = (res.results || []).map(r => `${r.number ? r.number + ' ' : ''}${r.name}: ${r.code}`);
    if (codes.length) setTimeout(() => alert(`등록된 학생 코드:\n\n` + codes.join('\n')), 400);
  } catch(e) {
    hideLoading();
    toast('❌ 등록 중 오류: ' + (e.message || ''));
  }
}
async function addStudent() {
  const name = document.getElementById("new-s-name").value.trim();
  const cls  = document.getElementById("new-s-class").value.trim();
  const num  = document.getElementById("new-s-number").value.trim();
  if (!name || !cls) { toast("클래스와 이름을 입력해주세요."); return; }
  showLoading("추가 중...");
  const res = await api({ action:"addStudent", password:teacherPw, name, class_name:cls, number:num });
  hideLoading();
  if (res.success) { toast(`✅ ${name} 추가! 코드: ${res.code}`); document.getElementById("new-s-name").value = ''; document.getElementById("new-s-number").value = ''; hideAddStudentForm(); loadStudents(); }
  else toast("❌ " + res.message);
}
function showAddClassModal() { document.getElementById('new-class-name').value = ''; document.getElementById('add-class-modal').classList.remove('hidden'); document.getElementById('new-class-name').focus(); }
function closeAddClassModal() { document.getElementById('add-class-modal').classList.add('hidden'); }
async function addClassRoom() {
  const name = document.getElementById('new-class-name').value.trim();
  if (!name) { toast('클래스명을 입력해주세요.'); return; }
  showLoading('추가 중...');
  const res = await api({ action:'addClass', password:teacherPw, class_name:name });
  hideLoading();
  if (res.success) { toast('✅ 클래스가 추가되었습니다.'); closeAddClassModal(); allClasses.push({ id:res.id, name, created_at:'' }); renderSidebarClassList(); populateClassSelect(); } else toast('❌ ' + res.message);
}

// ── 클래스명 수정 ──
let renamingClassId = null;
function openRenameClassModal(classId) {
  const c = allClasses.find(x => String(x.id) === String(classId));
  if (!c) return;
  renamingClassId = classId;
  const input = document.getElementById('rename-class-name');
  input.value = c.name;
  document.getElementById('rename-class-modal').classList.remove('hidden');
  input.focus();
  input.select();
}
function closeRenameClassModal() {
  document.getElementById('rename-class-modal').classList.add('hidden');
  renamingClassId = null;
}
async function submitRenameClass() {
  if (!renamingClassId) return;
  const c = allClasses.find(x => String(x.id) === String(renamingClassId));
  const newName = document.getElementById('rename-class-name').value.trim();
  if (!newName) { toast('클래스명을 입력해주세요.'); return; }
  if (c && c.name === newName) { closeRenameClassModal(); return; }
  const oldName = c ? c.name : '';
  showLoading('변경 중...');
  const res = await api({ action:'renameClass', password:teacherPw, class_id:renamingClassId, new_name:newName });
  hideLoading();
  if (!res.success) { toast('❌ ' + res.message); return; }
  toast('✅ ' + res.message);
  closeRenameClassModal();
  if (c) c.name = res.name || newName;
  // ★ 이름이 바뀐 클래스에 들어가 있었다면 화면의 클래스명도 함께 갱신해야 한다.
  //   안 그러면 예전 이름으로 계속 조회해서 학생이 하나도 없는 것처럼 보인다.
  if (enteredClass === oldName) {
    enteredClass = res.name || newName;
    selectedClass = enteredClass;
    const banner = document.getElementById('entered-class-name');
    if (banner) banner.textContent = enteredClass;
  }
  renderSidebarClassList();
  populateClassSelect();
  await refreshAfterClassChange();
}

// ── 클래스 삭제 ──
async function confirmDeleteClass(classId) {
  const c = allClasses.find(x => String(x.id) === String(classId));
  if (!c) return;
  if (!confirm(`'${c.name}' 클래스를 삭제할까요?\n\n학생·과제·제출물이 남아 있으면 삭제되지 않고 안내만 표시됩니다.`)) return;
  showLoading('삭제 중...');
  const res = await api({ action:'deleteClass', password:teacherPw, class_id:classId });
  hideLoading();
  if (!res.success) {
    // 남은 자료가 있어 막힌 경우는 토스트가 짧아 놓치기 쉬우므로 창으로 알린다.
    if (res.blocked) alert(res.message); else toast('❌ ' + res.message);
    return;
  }
  toast('✅ ' + res.message);
  allClasses = allClasses.filter(x => String(x.id) !== String(classId));
  if (enteredClass === c.name) { exitClass(); }
  renderSidebarClassList();
  populateClassSelect();
}

// 클래스명이 바뀐 뒤 현재 보고 있는 화면을 다시 그린다.
async function refreshAfterClassChange() {
  try {
    const aRes = await api({ action:'getAssignments' });
    allAssignments = aRes.assignments || [];
    const sRes = await api({ action:'getStudents', password:teacherPw });
    allStudents = sRes.students || [];
    if (selectedClass) loadStudentCardsForClass(selectedClass);
    if (document.getElementById('panel-manage-students').classList.contains('active')) renderStudentTable(allStudents);
    if (document.getElementById('panel-manage-assign').classList.contains('active')) loadTeacherAssignmentList();
  } catch(e) {}
}
async function loadTeacherAssignmentList() {
  showLoading();
  const res = await api({ action:'getAssignments' });
  hideLoading();
  const list = (res.assignments || []).filter(a => { if (!enteredClass) return true; return !a.class_target || sameClassName(a.class_target, enteredClass); });
  const el = document.getElementById('t-assignment-list');
  if (!list.length) { el.innerHTML = `<div class="empty-state"><div class="icon">📋</div><p>등록된 과제가 없습니다.</p></div>`; return; }
  // ★ 등록 순서 번호(#N)를 정렬하기 전에 먼저 매겨둔다.
  //   '학생별 보기'의 "과제 N" 은 등록 순서를 쓰므로, 여기서 번호를 다시 매기면
  //   같은 과제가 화면마다 다른 번호로 보이게 된다.
  list.forEach((a, i) => { a._no = i + 1; });
  // ★ 최신 과제가 위로 오도록 정렬 (등록일 내림차순).
  //   created_at 은 "yyyy-MM-dd HH:mm:ss" 라 문자열 비교로 시간순이 맞다.
  //   값이 비어 있거나 같으면 나중에 등록된 것(번호가 큰 것)을 위로 보낸다.
  const sorted = [...list].sort((a, b) => {
    const ta = String(a.created_at || ''), tb = String(b.created_at || '');
    if (ta && tb && ta !== tb) return tb.localeCompare(ta);
    return b._no - a._no;
  });
  el.innerHTML = sorted.map((a,i) => `
    <div class="assign-list-row">
      <span style="font-size:20px">📋</span>
      <div class="alr-info">
        <div class="alr-title">#${a._no} ${escHtml(a.title)}</div>
        <div class="alr-meta">${a.due_date||'마감없음'} · ${a.class_target||'전체'}</div>
      </div>
      <div class="alr-actions">
        <button class="btn-edit-assign" onclick="openEditAssignModal(${i})">✏️ 수정</button>
        <button class="btn-del-assign" onclick="confirmDeleteAssignment('${escAttr(a.id)}','${escAttr(a.title)}')">🗑 삭제</button>
      </div>
    </div>`).join('');
  // 과제 데이터 캐시 (수정 모달용) — 반드시 화면에 그린 순서와 같아야 한다.
  window._assignListCache = sorted;
  populateClassSelect();
}
async function addAssignment() {
  const title = document.getElementById('new-a-title').value.trim();
  const desc  = document.getElementById('new-a-desc').value.trim();
  const due   = document.getElementById('new-a-due').value;
  const classTgt = document.getElementById('new-a-class').value;
  if (!title) { toast('과제명을 입력해주세요.'); return; }
  let fileParam = '';
  fileParam = packFiles(teacherUploadedFiles);
  showLoading('등록 중...');
  const res = await api({ action:'addAssignment', password:teacherPw, title, description:desc, due_date:due, class_target:classTgt, file_url:fileParam });
  hideLoading();
  if (res.success) {
    toast('✅ 과제가 등록되었습니다.');
    document.getElementById('new-a-title').value = ''; document.getElementById('new-a-desc').value = ''; document.getElementById('new-a-due').value = ''; document.getElementById('new-a-class').value = '';
    teacherUploadedFiles = []; document.getElementById('t-file-preview').innerHTML = '';
    const inp = document.getElementById('t-file-input'); if (inp) inp.value = '';
    allAssignments = (await api({ action:'getAssignments' })).assignments || [];
    loadTeacherAssignmentList();
  } else toast('❌ ' + res.message);
}

// ── 과제 수정 모달 ───────────────────────────────
function openEditAssignModal(idx) {
  const a = (window._assignListCache || [])[idx];
  if (!a) return;
  document.getElementById('edit-a-id').value    = a.id;
  document.getElementById('edit-a-title').value  = a.title;
  document.getElementById('edit-a-desc').value   = a.description || '';
  document.getElementById('edit-a-due').value    = a.due_date || '';
  const inp = document.getElementById('edit-file-input'); if (inp) inp.value = '';

  // ★ 기존 첨부를 목록으로 불러둔다. 여기서 하나씩 지우거나 더 추가할 수 있다.
  window._editOriginalAssign = a;
  editAssignUploadedFiles = unpackFiles(a.file_url, a.file_name, a.mime_type);
  renderFilePreview('edit-file-preview', 'teacher');
  renderEditFileCurrent();

  // 수업장소 셀렉트 채우기
  const sel = document.getElementById('edit-a-class');
  sel.innerHTML = '<option value="">전체 공개</option>';
  (allClasses || []).forEach(c => {
    const opt = document.createElement('option');
    opt.value = c.name; opt.textContent = c.name;
    if (sameClassName(c.name, a.class_target)) opt.selected = true;
    sel.appendChild(opt);
  });

  document.getElementById('modal-edit-assign').classList.add('open');
}

// ★ 첨부 상태 표시 + '첨부 제거' 버튼
//   이전 버전에는 첨부만 떼어낼 방법이 아예 없었다.
function renderEditFileCurrent() {
  const curEl = document.getElementById('edit-a-file-current');
  if (!curEl) return;
  const n = editAssignUploadedFiles.length;
  const had = !!(window._editOriginalAssign && window._editOriginalAssign.file_url);
  if (n) {
    curEl.innerHTML = `현재 첨부 <b>${n}개</b>
      <button class="btn-outline btn-sm" style="margin-left:6px" onclick="removeEditAssignFile()">전부 제거</button>
      <div style="color:var(--text3);font-size:11px;margin-top:4px">아래 목록에서 하나씩 삭제하거나, 새 파일을 더 추가할 수 있습니다.</div>`;
  } else if (had) {
    curEl.innerHTML = '<span style="color:var(--notsubmit-text);font-weight:700">첨부 없음 — 저장하면 기존 첨부가 제거됩니다</span>';
  } else {
    curEl.innerHTML = '<span style="color:var(--text3)">첨부파일 없음</span>';
  }
}
function removeEditAssignFile() {
  editAssignUploadedFiles = [];
  document.getElementById('edit-file-preview').innerHTML = '';
  const inp = document.getElementById('edit-file-input'); if (inp) inp.value = '';
  renderEditFileCurrent();
}
function closeEditAssignModal() {
  document.getElementById('modal-edit-assign').classList.remove('open');
  editAssignUploadedFiles = [];
}

async function saveEditAssignment() {
  const id    = document.getElementById('edit-a-id').value;
  const title = document.getElementById('edit-a-title').value.trim();
  const desc  = document.getElementById('edit-a-desc').value.trim();
  const due   = document.getElementById('edit-a-due').value;
  const classTgt = document.getElementById('edit-a-class').value;
  if (!title) { toast('과제명을 입력해주세요.'); return; }

  // 파일 처리
  //  ★ 모달을 열 때 기존 첨부를 목록으로 불러오므로, 화면의 목록 전체를 그대로 보낸다.
  //     (하나씩 지우거나 더 추가한 결과가 그대로 저장된다. 목록이 비면 첨부 제거)
  const fileParam = packFiles(editAssignUploadedFiles);
  const keepFile = '';

  showLoading('수정 중...');
  const res = await api({ action:'updateAssignment', password:teacherPw, assignment_id:id, title, description:desc, due_date:due, class_target:classTgt, file_url:fileParam, keep_file:keepFile });
  hideLoading();
  if (res.success) {
    toast('✅ 과제가 수정되었습니다.');
    closeEditAssignModal();
    allAssignments = (await api({ action:'getAssignments' })).assignments || [];
    loadTeacherAssignmentList();
  } else toast('❌ ' + res.message);
}

// ── 과제 삭제 확인 팝업 ──────────────────────────
function confirmDeleteAssignment(assignId, assignTitle) {
  const msg = `정말 삭제하시겠습니까?\n\n📋 ${assignTitle}\n\n⚠️ 이 과제에 연결된 학생 제출물과 피드백도 모두 삭제됩니다.\n삭제 후에는 복구할 수 없습니다.`;
  if (!confirm(msg)) return;
  doDeleteAssignment(assignId);
}

async function doDeleteAssignment(assignId) {
  showLoading('삭제 중...');
  const res = await api({ action:'deleteAssignment', password:teacherPw, assignment_id:assignId });
  hideLoading();
  if (res.success) {
    toast('🗑 과제와 관련 제출물이 삭제되었습니다.');
    allAssignments = (await api({ action:'getAssignments' })).assignments || [];
    loadTeacherAssignmentList();
  } else toast('❌ ' + res.message);
}
async function loadMatrixView() {
  if (!enteredClass) { document.getElementById('matrix-container').innerHTML = `<div class="empty-state"><div class="icon">📊</div><p>클래스에 먼저 입장하세요.</p></div>`; return; }
  showLoading();
  try {
    const [sRes, aRes, subRes] = await Promise.all([api({ action:'getStudents', password:teacherPw }), api({ action:'getAssignments' }), api({ action:'getAllSubmissions', password:teacherPw })]);
    allStudents = sRes.students || []; allAssignments = aRes.assignments || []; allSubmissions = subRes.submissions || [];
    hideLoading(); renderMatrix();
  } catch(e) { hideLoading(); toast('❌ 오류: ' + e.message); }
}
function renderMatrix() {
  const classStudents = allStudents.filter(s => sameClassName(s.class, enteredClass));
  const classAssignments = allAssignments.filter(a => !a.class_target || sameClassName(a.class_target, enteredClass));
  if (!classStudents.length || !classAssignments.length) { document.getElementById('matrix-container').innerHTML = `<div class="empty-state"><div class="icon">📊</div><p>학생 또는 과제가 없습니다.</p></div>`; return; }
  const subMap = {};
  allSubmissions.forEach(s => { const key = s.student_code + '||' + s.assignment_id; if (!subMap[key] || s.submitted_at > subMap[key].submitted_at) subMap[key] = s; });
  const submitCounts = {};
  classStudents.forEach(s => { submitCounts[s.code] = classAssignments.filter(a => subMap[s.code+'||'+a.id]).length; });
  const sortBy = document.getElementById('matrix-sort').value;
  let sorted = [...classStudents];
  if (sortBy === 'name') sorted.sort((a,b) => a.name.localeCompare(b.name,'ko'));
  else if (sortBy === 'number') sorted.sort((a,b) => String(a.number).localeCompare(String(b.number)));
  else if (sortBy === 'submit_asc') sorted.sort((a,b) => (submitCounts[a.code]||0)-(submitCounts[b.code]||0));
  else if (sortBy === 'submit_desc') sorted.sort((a,b) => (submitCounts[b.code]||0)-(submitCounts[a.code]||0));
  let html = '<table class="matrix-table"><thead><tr><th>학생</th>';
  classAssignments.forEach((a,i) => { html += `<th title="${escHtml(a.title)}">#${i+1}</th>`; });
  html += '<th>제출수</th></tr></thead><tbody>';
  sorted.forEach(s => {
    html += `<tr><td>${escHtml(s.name)} <span style="color:var(--text3);font-size:10px">${escHtml(s.number||'')}</span></td>`;
    classAssignments.forEach(a => {
      const sub = subMap[s.code + '||' + a.id];
      const isRejected = sub && sub.feedback && sub.feedback.is_rejected;
      let icon = '❌', bg = 'var(--notsubmit-bg)';
      if (sub && !isRejected) { const hasFb = sub.feedback && !sub.feedback.is_rejected; icon = hasFb ? '⭐' : '✅'; bg = 'var(--submitted-bg)'; } else if (isRejected) { icon = '⚠️'; bg = 'var(--rejected-bg)'; }
      html += `<td style="background:${bg};text-align:center" class="matrix-cell" onclick="openSubmissionModal('${escAttr(sub?sub.id:'')}','${escAttr(s.code)}','${escAttr(a.id)}','${escAttr(s.name)}','${escAttr(a.title)}')">${icon}</td>`;
    });
    html += `<td style="text-align:center;font-weight:800">${submitCounts[s.code]||0}/${classAssignments.length}</td></tr>`;
  });
  html += '</tbody></table>';
  document.getElementById('matrix-container').innerHTML = html;
}


// ══════════════════════════════════════════════════════
// ██ 도장(참 잘했어요) · 학급공약 ██
// ══════════════════════════════════════════════════════
//
// 도장은 피드백과 함께 저장되므로 별도로 불러오지 않는다.
//   · 학생 화면: getMySubmissions 응답에 이미 들어 있다 (추가 호출 없음)
//   · 교사 화면: 이 패널을 열 때만 getStampBoard를 한 번 부른다

// ── 학생: 내 도장 · 우리 반 현황 ──
function renderMyStampHero(res) {
  const el = document.getElementById('my-stamp-hero');
  if (!el) return;

  const mine = res.my_stamps || 0;
  const b    = res.stamp_board || null;

  // 반 정보가 없으면(학생목록에서 반을 못 찾은 경우) 내 도장만 보여준다
  if (!b || !b.class_name) {
    el.innerHTML = `<div class="stamp-hero">
      <div class="stamp-hero-mine"><span class="stamp-hero-label">내 도장</span><span class="stamp-hero-num">${mine}</span></div>
      <div class="stamp-hero-body">
        <div class="stamp-hero-title">지금까지 모은 도장이에요 🏅</div>
        <div class="stamp-hero-note">과제를 잘 해내면 선생님이 도장을 찍어 주세요.</div>
      </div>
    </div>`;
    return;
  }

  // 진행 중인 공약 중 가장 가까운 것(목표가 가장 작은 것)을 보여준다
  const active = (b.pledges || []).filter(p => p.status !== '완료').sort((x, y) => x.goal - y.goal);
  const doneCount = (b.pledges || []).filter(p => p.status === '완료').length;
  const goal = active.length ? active[0] : null;

  let body;
  if (goal) {
    const pct   = goal.goal > 0 ? Math.min(100, Math.round(b.available / goal.goal * 100)) : 0;
    const ready = b.available >= goal.goal;
    const left  = Math.max(0, goal.goal - b.available);
    body = `<div class="stamp-hero-title">
        <span>🎯 ${escHtml(goal.content)}</span>
        <span style="color:var(--text2)">${b.available} / ${goal.goal}개</span>
      </div>
      <div class="stamp-bar"><div class="stamp-bar-fill ${ready ? 'done' : ''}" style="width:${pct}%"></div></div>
      <div class="stamp-hero-note">${ready
        ? '목표 달성! 선생님이 공약을 실시해 주실 거예요 🎉'
        : `${escHtml(b.class_name)} 우리 반이 함께 모은 도장이에요. ${left}개만 더 모으면 돼요!`}</div>`;
  } else {
    body = `<div class="stamp-hero-title">
        <span>${escHtml(b.class_name)} 우리 반 도장</span>
        <span style="color:var(--text2)">${b.available}개</span>
      </div>
      <div class="stamp-hero-note">아직 정해진 학급공약이 없어요.${doneCount ? ` (지금까지 공약 ${doneCount}개 달성!)` : ''}</div>`;
  }

  el.innerHTML = `<div class="stamp-hero">
    <div class="stamp-hero-mine"><span class="stamp-hero-label">내 도장</span><span class="stamp-hero-num">${mine}</span></div>
    <div class="stamp-hero-body">${body}</div>
  </div>`;
}

// ── 교사: 도장 현황판 불러오기 ──
async function loadStampBoard() {
  const el  = document.getElementById('stamp-board');
  const cls = enteredClass || selectedClass;
  if (!cls) {
    el.innerHTML = `<div class="empty-state"><div class="icon">👈</div><p>왼쪽에서 클래스를 선택하세요</p></div>`;
    return;
  }
  showLoading();
  try {
    const res = await api({ action: 'getStampBoard', password: teacherPw, class_name: cls });
    hideLoading();
    if (!res.success) { toast('❌ ' + res.message); return; }
    stampBoard = res;
    renderStampBoard();
  } catch (e) { hideLoading(); toast('❌ 오류: ' + e.message); }
}

function renderStampBoard() {
  const b = stampBoard;
  if (!b) return;
  const el = document.getElementById('stamp-board');

  // 도장 획득 1~3위 (동점자는 같은 등수로 묶는다)
  const rankGroups = [];
  [...(b.students || [])].filter(s => s.stamps > 0).sort((x, y) => y.stamps - x.stamps).forEach(s => {
    const g = rankGroups.find(g => g.stamps === s.stamps);
    if (g) g.names.push(s.name);
    else if (rankGroups.length < 3) rankGroups.push({ stamps: s.stamps, names: [s.name] });
  });
  const medals = ['🥇', '🥈', '🥉'];
  const rankHtml = rankGroups.length
    ? rankGroups.map((g, i) => `<div class="stamp-rank-row">
        <span class="srk-medal">${medals[i]}</span>
        <span class="srk-name">${escHtml(g.names.slice(0, 2).join(', '))}${g.names.length > 2 ? ` 외 ${g.names.length - 2}명` : ''}</span>
        <span class="srk-num">${g.stamps}개</span>
      </div>`).join('')
    : `<div class="stamp-rank-empty">아직 도장을 받은 학생이 없어요</div>`;

  const stats = `<div class="stamp-stats">
    <div class="stamp-stat">
      <div class="stamp-stat-label">지금까지 모은 도장</div>
      <div class="stamp-stat-num" style="color:var(--text)">${b.earned}<span class="stamp-stat-unit">개</span></div>
    </div>
    <div class="stamp-stat">
      <div class="stamp-stat-label">공약 실시로 사용</div>
      <div class="stamp-stat-num" style="color:var(--text3)">${b.redeemed}<span class="stamp-stat-unit">개</span></div>
    </div>
    <div class="stamp-stat" style="border-color:var(--accent2)">
      <div class="stamp-stat-label">남은 도장</div>
      <div class="stamp-stat-num" style="color:var(--accent2)">${b.available}<span class="stamp-stat-unit">개</span></div>
    </div>
    <div class="stamp-stat stamp-rank">
      <div class="stamp-stat-label">🏅 도장 많이 받은 학생</div>
      <div class="stamp-rank-list">${rankHtml}</div>
    </div>
  </div>`;

  const form = `<div class="card">
    <div style="font-size:13px;font-weight:800;margin-bottom:10px">＋ 학급공약 추가</div>
    <div class="pledge-form">
      <input type="text" id="pledge-content" class="pledge-input-text" placeholder="예: 다 같이 영화 보는 날" maxlength="120" onkeydown="if(event.key==='Enter')doAddPledge()">
      <input type="number" id="pledge-goal" class="pledge-input-goal" min="1" placeholder="목표 도장" onkeydown="if(event.key==='Enter')doAddPledge()">
      <button class="btn-primary" onclick="doAddPledge()">등록</button>
    </div>
  </div>`;

  const pledges = b.pledges || [];
  const active  = pledges.filter(p => p.status !== '완료').sort((x, y) => x.goal - y.goal);
  const done    = pledges.filter(p => p.status === '완료');

  const activeHtml = active.length ? active.map(p => {
    const ready = b.available >= p.goal;
    const pct   = p.goal > 0 ? Math.min(100, Math.round(b.available / p.goal * 100)) : 0;
    return `<div class="pledge-card ${ready ? 'ready' : ''}">
      <div class="pledge-head">
        <div class="pledge-text">🎯 ${escHtml(p.content)}</div>
        <div class="pledge-actions">
          <button class="btn-primary btn-sm"${ready ? '' : ' disabled style="opacity:.4;cursor:not-allowed"'} onclick="doExecutePledge('${escAttr(p.id)}')">공약 실시</button>
          <button class="btn-outline btn-sm" onclick="doDeletePledge('${escAttr(p.id)}')">삭제</button>
        </div>
      </div>
      <div class="stamp-bar"><div class="stamp-bar-fill ${ready ? 'done' : ''}" style="width:${pct}%"></div></div>
      <div class="pledge-meta">목표 ${p.goal}개 · 남은 도장 ${b.available}개 ${ready
        ? '— 목표 달성! 실시할 수 있습니다.'
        : `— ${p.goal - b.available}개 더 필요합니다.`}</div>
    </div>`;
  }).join('') : `<div class="empty-state" style="padding:30px 20px"><div class="icon">🎯</div><p>진행 중인 학급공약이 없습니다.</p></div>`;

  const doneHtml = done.length ? `<div class="stamp-sub">✅ 실시 완료한 공약</div>` + done.map(p => `
    <div class="pledge-card done">
      <div class="pledge-head">
        <div class="pledge-text">🎉 ${escHtml(p.content)}</div>
        <div class="pledge-actions">
          <button class="btn-outline btn-sm" onclick="doDeletePledge('${escAttr(p.id)}')">삭제</button>
        </div>
      </div>
      <div class="pledge-meta">${fmtDate(p.executed_at)} 실시 · 도장 ${p.goal}개 차감</div>
    </div>`).join('') : '';

  const students = b.students || [];
  const studentsHtml = students.length
    ? `<div class="stamp-student-grid">${students.map(s => `
        <div class="stamp-student ${s.stamps ? '' : 'zero'}">
          <div class="stamp-student-name">${escHtml(s.name)}</div>
          <div class="stamp-student-num">${escHtml(s.number || '')}</div>
          <div class="stamp-student-count">🏅 ${s.stamps}</div>
        </div>`).join('')}</div>`
    : `<div class="empty-state" style="padding:30px 20px"><div class="icon">👤</div><p>등록된 학생이 없습니다.</p></div>`;

  el.innerHTML = stats
    + `<div class="stamp-sub">🎯 진행 중인 학급공약</div>` + activeHtml
    + form
    + doneHtml
    + `<div class="stamp-sub">🏅 학생별 도장 누계</div>`
    + studentsHtml;
}

// ── 학급공약 등록 ──
async function doAddPledge() {
  const cls = enteredClass || selectedClass;
  if (!cls) { toast('클래스를 먼저 선택해주세요.'); return; }
  const content = document.getElementById('pledge-content').value.trim();
  const goal    = parseInt(document.getElementById('pledge-goal').value, 10);
  if (!content) { toast('공약 내용을 입력해주세요.'); return; }
  if (isNaN(goal) || goal < 1) { toast('목표 도장 개수를 1개 이상으로 입력해주세요.'); return; }

  showLoading('등록 중...');
  const res = await api({ action: 'addPledge', password: teacherPw, class_name: cls, content, goal });
  hideLoading();
  if (res.success) { toast('✅ ' + res.message); loadStampBoard(); }
  else toast('❌ ' + res.message);
}

// ── 공약 실시 (도장 차감) ──
async function doExecutePledge(pledgeId) {
  const p = (stampBoard && stampBoard.pledges || []).find(x => x.id === pledgeId);
  if (!p) return;
  if (!confirm(`"${p.content}"\n\n공약을 실시하고 학급 도장 ${p.goal}개를 차감합니다.\n계속할까요?`)) return;

  showLoading('처리 중...');
  const res = await api({ action: 'executePledge', password: teacherPw, pledge_id: pledgeId });
  hideLoading();
  if (res.success) { toast(res.message); loadStampBoard(); }
  else toast('❌ ' + res.message);
}

// ── 공약 삭제 ──
async function doDeletePledge(pledgeId) {
  const p = (stampBoard && stampBoard.pledges || []).find(x => x.id === pledgeId);
  if (!p) return;
  // 이미 실시한 공약을 지우면 그때 깎았던 도장이 되살아나므로 미리 알려 준다
  const warn = p.status === '완료'
    ? `\n\n※ 이미 실시한 공약입니다. 삭제하면 차감했던 도장 ${p.goal}개가 잔여로 되돌아옵니다.`
    : '';
  if (!confirm(`"${p.content}"\n\n이 학급공약을 삭제할까요?${warn}`)) return;

  showLoading('삭제 중...');
  const res = await api({ action: 'deletePledge', password: teacherPw, pledge_id: pledgeId });
  hideLoading();
  if (res.success) { toast('✅ ' + res.message); loadStampBoard(); }
  else toast('❌ ' + res.message);
}


// ══════════════════════════════════════════════════════
// ██ 워드클라우드 시스템 — GAS 연동 버전 ██
// ══════════════════════════════════════════════════════

// ── 워드클라우드 상태 ──
let wcSession = null;
let wcPollingTimer = null;
let wcSessions = [];
let wcPresets = [];
let wcStudentId = null;
let wcStudentSubmitCount = 0;
let wcCountValue = 5;

// ── 로컬 스토리지 (프리셋·히스토리 표시용만 유지) ──
function wcLoadLocal() {
  try { wcSessions = JSON.parse(localStorage.getItem('wc_sessions') || '[]'); } catch(e) { wcSessions = []; }
  try { wcPresets  = JSON.parse(localStorage.getItem('wc_presets')  || '[]'); } catch(e) { wcPresets  = []; }
}
function wcSaveLocal() {
  try { localStorage.setItem('wc_sessions', JSON.stringify(wcSessions.slice(-20))); } catch(e) {}
}
wcLoadLocal();

// ── QR 코드 생성 (QuickChart API) ──
const WC_QR_SIZE_NORMAL = 140;
let wcCurrentQrUrl = ''; // 지금 QR에 그려진 주소 (전체화면 전환 시 다시 그리는 용도)

function wcGenerateQR(url, canvasEl, size) {
  size = size || WC_QR_SIZE_NORMAL;
  wcCurrentQrUrl = url;
  canvasEl.width = size; canvasEl.height = size;
  const ctx = canvasEl.getContext('2d');
  const img = new Image();
  img.crossOrigin = 'anonymous';
  img.onload = () => { ctx.drawImage(img, 0, 0, size, size); };
  img.onerror = () => {
    ctx.fillStyle = '#ffffff'; ctx.fillRect(0, 0, size, size);
    ctx.fillStyle = '#c8974a'; ctx.font = 'bold ' + Math.round(size * 0.07) + 'px sans-serif';
    ctx.textAlign = 'center';
    ctx.fillText('QR 생성 실패', size / 2, size / 2 - 6);
    ctx.font = Math.round(size * 0.06) + 'px sans-serif'; ctx.fillStyle = '#888';
    ctx.fillText('인터넷 연결 확인', size / 2, size / 2 + 10);
  };
  img.src = 'https://quickchart.io/qr?size=' + size + '&text=' + encodeURIComponent(url);
}

// ── QR 전체화면 보기 ──
function wcToggleQrFullscreen() {
  const box = document.getElementById('wc-qr-box');
  if (!box) return;
  if (!document.fullscreenElement) { box.requestFullscreen && box.requestFullscreen(); }
  else { document.exitFullscreen && document.exitFullscreen(); }
}
// 지금 QR을 그려야 할 크기 — 전체화면이면 화면에 맞춰 크게, 아니면 기본 크기
function wcQrDisplaySize() {
  const box = document.getElementById('wc-qr-box');
  if (document.fullscreenElement === box) {
    return Math.min(900, Math.round(Math.min(window.innerWidth, window.innerHeight) * 0.8));
  }
  return WC_QR_SIZE_NORMAL;
}
document.addEventListener('fullscreenchange', () => {
  const canvas = document.getElementById('wc-qr-canvas');
  if (!canvas || !wcCurrentQrUrl) return;
  wcGenerateQR(wcCurrentQrUrl, canvas, wcQrDisplaySize());
});

// ── 세션 URL 생성 ──
// 구글 웹앱은 ?wc=세션ID 파라미터를 doGet(e.parameter.wc)으로 수신
function wcGetSessionUrl(sessionId) {
  const metaUrl = document.querySelector('meta[name="script-url"]');
  const base = metaUrl && metaUrl.content ? metaUrl.content : window.location.href.split('?')[0];
  return base + '?wc=' + sessionId;
}

// ── URL 단축 (QR을 단순하게 만들기 위함) ──
// 한 서비스가 막히거나 느려도 다음 서비스로 자동 시도한다.
// 전부 실패하면 원본(긴) 주소를 그대로 반환 — QR 자체는 항상 뜬다.
const WC_SHORTENER_TIMEOUT_MS = 4000;

function wcFetchWithTimeout(url, ms) {
  const ctrl = new AbortController();
  const timer = setTimeout(() => ctrl.abort(), ms);
  return fetch(url, { signal: ctrl.signal }).finally(() => clearTimeout(timer));
}

const WC_SHORTENER_PROVIDERS = [
  async function tinyurl(longUrl) {
    const res = await wcFetchWithTimeout('https://tinyurl.com/api-create.php?url=' + encodeURIComponent(longUrl), WC_SHORTENER_TIMEOUT_MS);
    const text = (await res.text()).trim();
    if (!res.ok || !/^https?:\/\//.test(text)) throw new Error('tinyurl 응답 이상');
    return text;
  },
  async function isgd(longUrl) {
    const res = await wcFetchWithTimeout('https://is.gd/create.php?format=json&url=' + encodeURIComponent(longUrl), WC_SHORTENER_TIMEOUT_MS);
    const data = await res.json();
    if (!data.shorturl) throw new Error('is.gd 응답 이상');
    return data.shorturl;
  },
  async function vgd(longUrl) {
    const res = await wcFetchWithTimeout('https://v.gd/create.php?format=json&url=' + encodeURIComponent(longUrl), WC_SHORTENER_TIMEOUT_MS);
    const data = await res.json();
    if (!data.shorturl) throw new Error('v.gd 응답 이상');
    return data.shorturl;
  }
];

async function wcShortenUrl(longUrl) {
  for (const provider of WC_SHORTENER_PROVIDERS) {
    try {
      const shortUrl = await provider(longUrl);
      return { url: shortUrl, shortened: true };
    } catch (e) {
      console.warn('[워드클라우드] URL 단축 실패(' + provider.name + '):', e && e.message);
    }
  }
  return { url: longUrl, shortened: false };
}

// ── GAS API 헬퍼 ──
function wcApi(params) {
  return new Promise((resolve, reject) => {
    google.script.run
      .withSuccessHandler(text => {
        try { resolve(JSON.parse(text)); }
        catch(e) { reject(new Error('응답 파싱 오류')); }
      })
      .withFailureHandler(err => reject(new Error(err.message || '통신 오류')))
      .apiHandler(params);
  });
}

// ── 설정 UI ──
function adjustWcCount(delta) {
  wcCountValue = Math.max(1, Math.min(20, wcCountValue + delta));
  document.getElementById('wc-count-display').textContent = wcCountValue;
}
function setWcQuestion(text) {
  document.getElementById('wc-question').value = text;
}
function wcSavePreset() {
  const q = document.getElementById('wc-question').value.trim();
  if (!q) { toast('저장할 질문을 입력해주세요.'); return; }
  if (!wcPresets.includes(q)) {
    wcPresets.push(q);
    try { localStorage.setItem('wc_presets', JSON.stringify(wcPresets)); } catch(e) {}
  }
  toast('✅ 프리셋에 저장되었습니다.');
  wcRenderPresets();
}
function wcLoadPresets() {
  wcLoadLocal();
  wcRenderPresets(true);
}
function wcRenderPresets(showSaved) {
  const container = document.getElementById('wc-preset-chips');
  const defaultPresets = ['이 주제에 대해 떠오르는 단어는?','수업 후 느낀 점 한 단어로?','오늘 기분을 한 단어로!','이번 학기 목표 키워드는?','이 작품의 인상을 한 단어로?'];
  const all = showSaved ? [...defaultPresets, ...wcPresets.filter(p => !defaultPresets.includes(p))] : defaultPresets;
  container.innerHTML = all.map(p => `<span class="wc-preset-chip" onclick="setWcQuestion(this.textContent)">${escHtml(p)}</span>`).join('');
}
function wcShowHistory() {
  const panel = document.getElementById('wc-history-panel');
  panel.classList.toggle('hidden');
  if (!panel.classList.contains('hidden')) wcRenderHistory();
}
function wcRenderHistory() {
  const el = document.getElementById('wc-history-list');
  if (!wcSessions.length) { el.innerHTML = '<div style="font-size:12px;color:var(--text3);padding:8px">기록이 없습니다.</div>'; return; }
  el.innerHTML = [...wcSessions].reverse().slice(0, 10).map(s => `
    <div class="wc-history-item">
      <div>
        <div style="font-size:13px;font-weight:800">${escHtml((s.question||'').slice(0,30))}${(s.question||'').length>30?'...':''}</div>
        <div style="font-size:11px;color:var(--text3)">${s.date||''} · 응답 ${(s.responses||[]).length}개</div>
      </div>
      <span style="font-size:18px">›</span>
    </div>`).join('');
}

// ── 세션 시작 ──
async function wcStartSession() {
  const q = document.getElementById('wc-question').value.trim();
  if (!q) { toast('질문을 입력해주세요.'); return; }
  if (!teacherPw) { toast('교사로 로그인 후 사용하세요.'); return; }

  const startBtn = document.getElementById('wc-start-btn');
  startBtn.disabled = true;
  showLoading('세션 생성 중...');

  try {
    const res = await wcApi({
      action: 'wcCreateSession',
      password: teacherPw,
      question: q,
      maxPerPerson: String(wcCountValue)
    });
    hideLoading();

    if (!res.success) {
      toast('❌ ' + res.message);
      startBtn.disabled = false;
      return;
    }

    wcSession = {
      id:           res.sessionId,
      question:     res.question,
      maxPerPerson: res.maxPerPerson,
      active:       true,
      responses:    [],
      participants: {},
      date:         new Date().toLocaleDateString('ko-KR')
    };

    // 로컬 히스토리에 기록 (표시용)
    wcSessions.push({ ...wcSession });
    wcSaveLocal();

    // 원본(긴) 주소로 QR을 먼저 즉시 띄운다 — 단축이 늦거나 실패해도 QR은 바로 뜬다.
    const longUrl = wcGetSessionUrl(res.sessionId);
    wcGenerateQR(longUrl, document.getElementById('wc-qr-canvas'));
    document.getElementById('wc-qr-url').textContent = longUrl;
    document.getElementById('wc-qr-shorten-status').textContent = '🔗 짧은 주소 만드는 중...';
    document.getElementById('wc-live-dot').classList.add('on');

    wcUpdateUI(true);
    wcStartPolling();
    toast('🟢 워드클라우드 세션이 시작되었습니다!');

    // 짧은 주소로 교체되면 QR이 더 단순해진다 (실패 시 긴 주소 그대로 유지)
    wcShortenUrl(longUrl).then(result => {
      if (!wcSession || wcSession.id !== res.sessionId) return; // 그새 세션이 바뀌었으면 무시
      wcGenerateQR(result.url, document.getElementById('wc-qr-canvas'), wcQrDisplaySize());
      document.getElementById('wc-qr-url').textContent = result.url;
      document.getElementById('wc-qr-shorten-status').textContent = result.shortened ? '' : '⚠ 단축 실패 · 원래 주소로 표시 중';
    });

  } catch(e) {
    hideLoading();
    startBtn.disabled = false;
    toast('❌ 세션 생성 실패: ' + e.message);
  }
}

// ── 세션 종료 ──
async function wcStopSession() {
  wcStopPolling();
  document.getElementById('wc-live-dot').classList.remove('on');

  if (wcSession && teacherPw) {
    try { await wcApi({ action: 'wcStopSession', password: teacherPw, sessionId: wcSession.id }); } catch(e) {}
    wcSession.active = false;
  }

  const startBtn = document.getElementById('wc-start-btn');
  startBtn.disabled = false;
  startBtn.classList.remove('hidden');
  document.getElementById('wc-stop-btn').classList.add('hidden');
  document.getElementById('wc-step1').classList.remove('active'); document.getElementById('wc-step1').classList.add('done');
  document.getElementById('wc-step2').classList.remove('active'); document.getElementById('wc-step2').classList.add('done');
  document.getElementById('wc-step3').classList.add('active');
  toast('⏹ 세션이 종료되었습니다.');
}

function wcUpdateUI(active) {
  const hasResponses = wcSession && wcSession.responses && wcSession.responses.length;
  document.getElementById('wc-start-btn').classList.toggle('hidden', active);
  document.getElementById('wc-stop-btn').classList.toggle('hidden', !active);
  document.getElementById('wc-qr-area').classList.toggle('hidden', !active);
  document.getElementById('wc-live-question').classList.toggle('hidden', !active);
  document.getElementById('wc-empty-state').style.display   = (active || hasResponses) ? 'none' : '';
  document.getElementById('wc-canvas-wrap').style.display   = hasResponses ? '' : 'none';
  document.getElementById('wc-responses-wrap').style.display = hasResponses ? '' : 'none';
  document.getElementById('wc-fullscreen-btn').classList.toggle('hidden', !wcSession);
  if (active && wcSession) {
    document.getElementById('wc-live-q-text').textContent = wcSession.question;
    document.getElementById('wc-step1').classList.remove('active'); document.getElementById('wc-step1').classList.add('done');
    document.getElementById('wc-step2').classList.add('active');   document.getElementById('wc-step2').classList.remove('done');
    document.getElementById('wc-step3').classList.remove('active'); document.getElementById('wc-step3').classList.remove('done');
  }
}

// ── GAS 폴링 (2초마다 응답 조회) ──
function wcStartPolling() {
  wcStopPolling();
  wcPollingTimer = setInterval(wcPollResponses, 2000);
}
function wcStopPolling() {
  if (wcPollingTimer) { clearInterval(wcPollingTimer); wcPollingTimer = null; }
}
async function wcPollResponses() {
  if (!wcSession || !wcSession.active) return;
  try {
    const res = await wcApi({ action: 'wcGetResponses', sessionId: wcSession.id });
    if (!res.success) return;
    const prevCount = (wcSession.responses || []).length;
    wcSession.responses    = res.responses    || [];
    wcSession.participants = res.participants  || {};
    document.getElementById('wc-response-count').textContent    = res.responseCount    || 0;
    document.getElementById('wc-word-count').textContent        = wcGetWordFreq().size;
    document.getElementById('wc-participant-count').textContent = res.participantCount || 0;
    // 새 응답이 생겼을 때만 재렌더
    if (wcSession.responses.length !== prevCount) {
      const hasR = wcSession.responses.length > 0;
      document.getElementById('wc-canvas-wrap').style.display    = hasR ? '' : 'none';
      document.getElementById('wc-responses-wrap').style.display = hasR ? '' : 'none';
      document.getElementById('wc-empty-state').style.display    = hasR ? 'none' : '';
      wcDrawCloud();
      wcRenderResponseChips();
    }
  } catch(e) {}
}

// ── 단어 정규화 ──
function wcNormalize(word) {
  word = (word || '').trim().toLowerCase();
  word = word.replace(/[!?.,~·。、]/g, '');
  word = word.replace(/(이|가|을|를|은|는|의|에|에서|으로|로|와|과|도|만|이다|다)$/, '');
  return word;
}
function wcGetWordFreq() {
  const freq = new Map();
  if (!wcSession || !wcSession.responses) return freq;
  wcSession.responses.forEach(r => {
    const norm = wcNormalize(r.word);
    if (!norm) return;
    freq.set(norm, (freq.get(norm) || 0) + 1);
  });
  return freq;
}

// ── 워드클라우드 캔버스 렌더링 ──
function wcDrawCloud() {
  if (!wcSession || !wcSession.responses || !wcSession.responses.length) return;
  const freq = wcGetWordFreq();
  if (!freq.size) return;
  const wrap   = document.getElementById('wc-canvas-wrap');
  const canvas = document.getElementById('wc-canvas');
  const W = wrap.clientWidth || 500;
  const H = Math.max(260, Math.min(400, W * 0.55));
  canvas.width = W; canvas.height = H;
  const ctx = canvas.getContext('2d');
  ctx.clearRect(0, 0, W, H);
  ctx.fillStyle = '#ffffff'; ctx.fillRect(0, 0, W, H);
  const words   = [...freq.entries()].sort((a, b) => b[1] - a[1]);
  const maxFreq = words[0][1];
  const minFreq = words[words.length - 1][1];
  const range   = maxFreq - minFreq || 1;
  const accentColor = getComputedStyle(document.documentElement).getPropertyValue('--wc-accent').trim() || '#c8974a';
  const palette = [accentColor,'#4a90d9','#2ecc71','#e74c3c','#9b59b6','#1abc9c','#e67e22','#f39c12','#16a085','#8e44ad'];
  const placed  = [];
  const cx = W / 2, cy = H / 2;
  words.forEach(([word, count], idx) => {
    const ratio    = (count - minFreq) / range;
    const fontSize = Math.round(12 + ratio * (Math.min(W, H) * 0.18));
    ctx.font = `bold ${fontSize}px "Nanum Gothic", sans-serif`;
    const tw = ctx.measureText(word).width;
    const th = fontSize * 1.2;
    const startAngle = Math.random() * Math.PI * 2;
    let placed_ok = false;
    for (let r = 0; r < Math.max(W, H); r += 4) {
      const angle = startAngle + r * 0.25;
      const x = cx + r * Math.cos(angle) - tw / 2;
      const y = cy + r * Math.sin(angle) + th / 3;
      const rect = { x, y: y - th, w: tw + 4, h: th + 4 };
      if (x < 2 || x + tw > W - 2 || y - th < 2 || y > H - 2) continue;
      const overlap = placed.some(p => !(rect.x + rect.w < p.x || rect.x > p.x + p.w || rect.y + rect.h < p.y || rect.y > p.y + p.h));
      if (!overlap) {
        placed.push(rect);
        ctx.fillStyle   = palette[idx % palette.length];
        ctx.globalAlpha = 0.85 + ratio * 0.15;
        ctx.fillText(word, x, y);
        ctx.globalAlpha = 1;
        placed_ok = true;
        break;
      }
    }
    if (!placed_ok) {
      const x = Math.random() * (W - tw - 4) + 2;
      const y = Math.random() * (H - th - 4) + th;
      ctx.fillStyle   = palette[idx % palette.length];
      ctx.globalAlpha = 0.7;
      ctx.font = `bold ${Math.max(10, fontSize * 0.6)}px "Nanum Gothic", sans-serif`;
      ctx.fillText(word, x, y);
      ctx.globalAlpha = 1;
    }
  });
}

function wcRenderResponseChips() {
  if (!wcSession) return;
  const freq   = wcGetWordFreq();
  const el     = document.getElementById('wc-responses-list');
  const colors = ['#4a90d9','#e8734a','#2ecc71','#9b59b6','#e74c3c','#1abc9c','#f39c12'];
  let i = 0;
  el.innerHTML = [...freq.entries()].sort((a, b) => b[1] - a[1]).map(([word, count]) => {
    const col  = colors[i++ % colors.length];
    const size = 11 + Math.min(count * 2, 12);
    return `<span class="wc-response-chip" style="background:${col}20;color:${col};border:1.5px solid ${col}40;font-size:${size}px">${escHtml(word)} <span style="opacity:.6">${count}</span></span>`;
  }).join('');
}

function wcToggleFullscreen() {
  const wrap = document.getElementById('wc-canvas-wrap');
  if (!document.fullscreenElement) { wrap.requestFullscreen && wrap.requestFullscreen(); }
  else { document.exitFullscreen && document.exitFullscreen(); }
}


// ══════════════════════════════════════════════════════
// ██ 학생 응답 페이지 (QR 스캔 접속) ██
// ══════════════════════════════════════════════════════

// ── 페이지 로드 시 wc 파라미터 확인 ──
// GAS doGet에서 meta 태그로 세션ID 주입 → 여기서 감지
(function () {
  const metaEl  = document.querySelector('meta[name="wc-session-id"]');
  const wcParam = (metaEl && metaEl.content) || new URLSearchParams(window.location.search).get('wc');
  if (wcParam) {
    document.querySelectorAll('.page').forEach(p => { p.style.display = 'none'; p.classList.remove('active'); });
    const el = document.getElementById('page-wc-student');
    el.style.display = 'flex'; el.classList.add('active');
    wcInitStudentPage(wcParam);
  }
})();

// ── 학생 응답 페이지 초기화 ──
async function wcInitStudentPage(sessionId) {
  // 학생 고유 ID — 같은 브라우저라면 재접속 시 동일 ID 유지
  try {
    wcStudentId = localStorage.getItem('wc_student_id');
    if (!wcStudentId) {
      wcStudentId = 'S_' + Math.random().toString(36).slice(2, 8).toUpperCase();
      localStorage.setItem('wc_student_id', wcStudentId);
    }
  } catch(e) {
    wcStudentId = 'S_' + Math.random().toString(36).slice(2, 8).toUpperCase();
  }

  document.getElementById('wc-s-question').textContent = '세션을 불러오는 중...';

  try {
    const res = await new Promise((resolve, reject) => {
      google.script.run
        .withSuccessHandler(t => { try { resolve(JSON.parse(t)); } catch(e) { reject(e); } })
        .withFailureHandler(reject)
        .apiHandler({ action: 'wcGetSession', sessionId });
    });

    if (!res.success) {
      document.getElementById('wc-s-question').textContent = '세션을 찾을 수 없습니다.';
      document.getElementById('wc-s-answer-area').innerHTML = '<div style="text-align:center;color:var(--text3);font-size:14px;padding:20px">QR코드를 다시 스캔하거나<br>선생님께 문의하세요.</div>';
      return;
    }
    if (!res.active) {
      document.getElementById('wc-s-question').textContent = res.question || '세션이 종료되었습니다.';
      document.getElementById('wc-s-answer-area').innerHTML = '<div style="text-align:center;color:var(--text3);font-size:14px;padding:20px">이 세션은 종료되었습니다.</div>';
      return;
    }

    document.getElementById('wc-s-question').textContent = res.question;

    const submitCount = (res.participants || {})[wcStudentId] || 0;
    wcStudentSubmitCount = submitCount;
    const maxCount = res.maxPerPerson || 5;
    updateWcStudentRemain(maxCount - submitCount, maxCount);

    if (submitCount >= maxCount) {
      document.getElementById('wc-s-answer-area').classList.add('hidden');
      document.getElementById('wc-s-done').classList.remove('hidden');
    } else {
      document.getElementById('wc-s-input').focus();
    }

  } catch(e) {
    document.getElementById('wc-s-question').textContent = '연결 오류가 발생했습니다.';
    document.getElementById('wc-s-answer-area').innerHTML = '<div style="text-align:center;color:var(--text3);font-size:14px;padding:20px">잠시 후 다시 시도해주세요.</div>';
  }
}

function updateWcStudentRemain(remain, max) {
  const el  = document.getElementById('wc-s-remain');
  el.textContent = remain <= 0 ? '모든 의견을 제출했습니다.' : `남은 제출: ${remain} / ${max}`;
  const btn = document.querySelector('.wc-student-submit-btn');
  if (btn) btn.disabled = remain <= 0;
}

// ── 학생 단어 제출 ──
async function wcStudentSubmit() {
  const input = document.getElementById('wc-s-input');
  const word  = input.value.trim();
  if (!word) { toast('단어를 입력해주세요.'); return; }

  const metaEl  = document.querySelector('meta[name="wc-session-id"]');
  const sessionId = (metaEl && metaEl.content) || new URLSearchParams(window.location.search).get('wc');
  if (!sessionId) { toast('세션 정보를 찾을 수 없습니다.'); return; }

  const btn = document.querySelector('.wc-student-submit-btn');
  if (btn) btn.disabled = true;

  try {
    const res = await new Promise((resolve, reject) => {
      google.script.run
        .withSuccessHandler(t => { try { resolve(JSON.parse(t)); } catch(e) { reject(e); } })
        .withFailureHandler(reject)
        .apiHandler({ action: 'wcSubmitWord', sessionId, word, studentId: wcStudentId });
    });

    if (!res.success) {
      toast('❌ ' + res.message);
      if (btn) btn.disabled = false;
      return;
    }

    wcStudentSubmitCount++;
    input.value = '';
    updateWcStudentRemain(res.remaining, res.total);

    if (res.remaining <= 0) {
      document.getElementById('wc-s-answer-area').classList.add('hidden');
      document.getElementById('wc-s-done').classList.remove('hidden');
    } else {
      toast('✅ 제출되었습니다!');
      if (btn) btn.disabled = false;
      input.focus();
    }

  } catch(e) {
    toast('❌ 제출 중 오류가 발생했습니다.');
    if (btn) btn.disabled = false;
  }
}

// ── 리사이즈 시 워드클라우드 재그리기 ──
window.addEventListener('resize', () => {
  if (wcSession && wcSession.responses && wcSession.responses.length) {
    setTimeout(wcDrawCloud, 100);
  }
});
</script>
<!-- 과제 수정 모달 -->
<div id="modal-edit-assign" onclick="if(event.target===this)closeEditAssignModal()">
  <div class="modal-box">
    <h3>✏️ 과제 수정</h3>
    <input type="hidden" id="edit-a-id">
    <div class="form-group"><label>과제명 *</label><input type="text" id="edit-a-title" placeholder="예: 1차시 활동지"></div>
    <div class="form-group"><label>설명</label><textarea id="edit-a-desc" style="min-height:70px" placeholder="과제 안내 내용"></textarea></div>
    <div class="form-row">
      <div class="form-group"><label>수업장소</label><select id="edit-a-class"><option value="">전체 공개</option></select></div>
      <div class="form-group"><label>마감일</label><input type="date" id="edit-a-due"></div>
    </div>
    <div class="form-group">
      <label>과제 참고 파일</label>
      <div id="edit-a-file-current" style="margin-bottom:6px;font-size:12px;color:var(--text2)"></div>
      <div class="file-drop-zone" id="edit-drop-zone"
        ondragover="handleDragOver(event,'edit-drop-zone')"
        ondragleave="handleDragLeave('edit-drop-zone')"
        ondrop="handleDrop(event,'edit-file-input','edit-file-preview','teacher')">
        <input type="file" id="edit-file-input" accept="image/*,.pdf" multiple
          onchange="handleFileSelect(this,'edit-file-preview','teacher')">
        <div class="file-drop-icon">📎</div>
        <div class="file-drop-text">파일을 추가하려면 클릭하거나 드래그 (여러 개 가능)</div>
        <div class="file-drop-hint">이미지(JPG, PNG 등) · PDF · 파일당 최대 50MB</div>
      </div>
      <div id="edit-upload-progress" class="upload-progress hidden"><div class="mini-spinner"></div><span>Drive에 업로드 중...</span></div>
      <div id="edit-file-preview"></div>
    </div>
    <div style="font-size:12px;color:var(--text3);margin-bottom:14px">※ 학생 제출물은 수정 후에도 유지됩니다.</div>
    <div class="form-actions">
      <button class="btn-outline" onclick="closeEditAssignModal()">취소</button>
      <button class="btn-primary" onclick="saveEditAssignment()">저장</button>
    </div>
  </div>
</div>

</body>
</html>

시트 ID를 입력하실 필요 없습니다

예전에는 코드 맨 위에 시트 ID를 직접 적어야 했지만, 이제는 자동으로 연결됩니다.

중요

최초 설정 한 번 실행

스프레드시트로 돌아와 새로고침(F5) 하면 상단에 [✏️ Done? Done!] 메뉴가 생깁니다.

"✅ 이 스프레드시트에 연결되었습니다" 안내가 뜨면 성공입니다.

[③ 예전 시트에서 가져오기]는 지금 누르지 않으셔도 됩니다

이건 데이터가 다른 시트에 있을 때 끌어오는 메뉴입니다. 쓰던 시트에 코드만 바꾸는 대부분의 경우엔 필요 없습니다. 바로 다음 단계인 '연결된 시트 확인'에서 낯선 시트가 뜨면 그때 쓰게 됩니다. (실수로 누르셔도 중복은 자동으로 걸러져 데이터가 망가지지 않습니다)

메뉴가 안 보이신다면?

Apps Script를 스프레드시트가 아닌 곳(script.google.com)에서 따로 만드신 경우입니다. setupSpreadsheet부터 실행하시면 오류가 납니다 — 순서가 다릅니다.

Apps Script 편집기에서 아래 함수를 새로 만들어 ▶ 실행하세요. (시트 주소를 통째로 붙여넣으셔도 됩니다)
function 시트연결() { bindSpreadsheet("여기에_시트주소_또는_ID"); }
"✅ 연결되었습니다"가 나오면, 이어서 setupSpreadsheet 을 실행하세요.
그다음 upgradeExisting 을 실행하시면 이 단계가 끝납니다.

[② 기존 데이터 이어쓰기]가 정확히 무엇을 하나요?

빠진 시트를 만들고(이미 있으면 건너뜀), 날짜·시각 서식을 고정하고, 예전 오류로 생긴 중복 과제ID·중복 학생코드를 정리합니다.

이번 v3.0에서는 여기에 더해 도장·학급공약에 필요한 자리를 만들어 둡니다 — 피드백 시트 맨 뒤에 도장 열이 하나 붙고, 학급공약 시트가 새로 생깁니다. 기존 피드백 내용은 그대로 있고 열 하나만 늘어납니다.

학생들이 쓰던 6자리 코드는 그대로 유지됩니다. 실행 후 뜨는 안내창에 "중복 학생코드 재발급: 0건"이라고 나오면 아무도 코드가 바뀌지 않은 것입니다. 0건이 아니라면 학생목록 시트에서 해당 학생의 새 코드를 확인해 알려주세요. 여러 번 실행해도 안전합니다.

배포 전 필수

연결된 시트 확인

지금 앱이 어느 시트를 보고 있는지 알려줍니다. 여기 뜨는 시트 이름이 평소 쓰시던 그 시트가 맞는지 확인해 주세요.

다른 시트가 뜬다면 배포하지 마세요

예전 버전은 코드 맨 위에 시트 ID를 직접 적는 방식이었습니다. 혹시 스크립트가 붙어 있는 시트와 거기 적어두셨던 시트가 서로 달랐다면, 이번 업데이트 후 앱이 다른 시트를 보게 되어 학생·과제가 하나도 없는 것처럼 보일 수 있습니다.

이럴 때 쓰는 메뉴가 있습니다 — [✏️ Done? Done!] → [③ 예전 시트에서 가져오기] 에 데이터가 들어 있는 원래 시트의 주소(또는 ID)를 붙여넣어 주세요. 학생·과제·제출물·피드백이 지금 시트로 옮겨오고, 6자리 코드도 그대로 유지됩니다. 옮겨온 뒤 [② 기존 데이터 이어쓰기]를 한 번 더 누르고 배포하세요.

이걸 해야 실제로 반영됩니다

새 버전으로 배포

Apps Script 편집기에서:

URL은 바뀌지 않습니다. 학생들에게 주소를 다시 알려줄 필요 없습니다. 다만 3단계를 먼저 하고 4단계를 하셔야 합니다 — 순서가 바뀌면 잠시 오류가 날 수 있습니다.

업데이트 후 확인해 보세요

✓기존 학생 명단과 과제가 그대로 남아 있는가 ← 가장 먼저 확인
✓학생 코드로 접속했을 때 그 반 과제가 빠짐없이 뜨는가 — 특히 "3-1"처럼 붙임표가 들어간 반 이름을 쓰시는 경우 꼭 확인해 주세요
✓과제를 누르면 선생님이 쓴 설명이 파란 박스로 보이는가
✓제출 시각이 실제 시각과 같은가
✓선생님 화면 사이드바에 📊 현황판 메뉴가 보이는가
✓제출물에 피드백을 하나 써 보고, 그 학생 코드로 접속해 실제로 보이는지 확인
✓선생님 화면 사이드바에 🏅 도장 · 학급공약 메뉴가 보이는가
✓피드백을 쓸 때 도장 버튼(1~3개)이 뜨고, 학생 화면 맨 위에 도장 개수가 보이는가
✓선생님 화면 사이드바에 ☁️ 워드클라우드 메뉴가 보이는가
✓학생 로그인 화면에 [이 기기에서 자동 로그인] 체크박스가 보이는가 — 체크하고 접속한 뒤 창을 닫았다 다시 열면 코드 없이 들어가지는가

문제가 생기면

학생도 과제도 하나도 없어요

데이터가 지워진 게 아니라 앱이 다른 시트를 보고 있는 것입니다. 안심하세요. [🔎 연결된 시트 확인]으로 어느 시트인지 보시고, 원래 시트가 아니라면 [③ 예전 시트에서 가져오기]에 원래 시트 주소를 넣어 데이터를 옮겨오세요. 그 뒤 [② 기존 데이터 이어쓰기]를 한 번 더 눌러주시면 됩니다.

예전에 써 둔 피드백이 학생에게 안 보여요

v2.2 이전에 저장된 피드백 중 일부는 엉뚱한 학생 앞으로 기록돼 아무에게도 보이지 않을 수 있습니다. 스프레드시트에서 [✏️ Done? Done!] → [🩺 피드백 연결 점검]을 실행하면 그런 기록을 행 번호까지 찾아줍니다. 시트를 건드리지 않고 알려주기만 하니 안심하고 눌러보셔도 됩니다. 목록에 뜬 피드백은 웹앱에서 해당 학생을 찾아 다시 저장하시면 정상적으로 보입니다. (새 코드로 바꾼 뒤부터 쓰는 피드백은 이런 일이 생기지 않습니다)

과제를 등록했는데 학생 화면에는 안 보여요

v3.0.1에서 고쳐진 문제입니다. "3-1"처럼 숫자와 붙임표로 된 반 이름이 구글 시트에서 날짜로 바뀌어 저장되는 바람에, 과제의 대상수업과 학생의 수업장소가 서로 다른 값이 되어 생겼습니다. 새 코드로 업데이트하시면 이미 잘못 저장된 과제까지 자동으로 되돌아가 학생 화면에 바로 나타납니다. 업데이트 후에도 안 보인다면 스프레드시트의 과제목록 시트 F열(대상수업)과 학생목록 시트 A열(수업장소)에 적힌 반 이름이 같은지 확인해 주세요. (모든 반에 보여주고 싶은 과제는 대상수업을 비워 두시면 됩니다)

"연결된 스프레드시트가 없습니다" 오류가 떠요

2단계의 [① 최초 설정]을 아직 안 하신 경우입니다. 실행해 주세요. 독립 프로젝트라면 bindSpreadsheet("시트주소")를 먼저 실행하셔야 합니다.

🏅 도장 · 학급공약 메뉴가 안 보여요

거의 대부분 4단계(새 버전으로 배포)를 아직 안 하신 경우입니다. 코드만 붙여넣고 저장한 상태에서는 학생·선생님이 보는 주소에 아직 예전 화면이 나옵니다. 배포까지 마치신 뒤 브라우저에서 새로고침(Ctrl+F5) 해 보세요.

학생이 워드클라우드 QR을 찍었는데 로그인 화면이 떠요

아직 4단계(새 버전으로 배포)가 안 끝난 상태입니다. 주소는 예전과 같지만 예전 버전에는 워드클라우드 참여 화면이 없어서 평소의 로그인 화면이 나옵니다. 배포를 마치신 뒤 세션을 다시 시작해 새 QR을 띄워 주세요. 참여에는 6자리 코드가 필요 없습니다.

자동 로그인을 켰는데 다음에 열면 코드를 또 물어봐요

학생이 로그아웃을 눌렀거나, 브라우저에서 시크릿(비공개) 창을 쓰거나 인터넷 사용기록·쿠키를 지운 경우입니다. 학생 코드는 그 기기의 브라우저에만 저장되기 때문에, 기록을 지우면 함께 사라집니다. 다시 코드를 입력하고 체크박스를 켜 주시면 됩니다. (다른 기기나 다른 브라우저에는 저장이 따라가지 않습니다)

공용 태블릿에서 자동 로그인을 켰는데 어떻게 끄나요?

그 기기에서 학생 화면의 로그아웃을 한 번 누르면 저장된 코드가 지워집니다. 또는 로그인 화면에서 체크를 푼 채로 코드를 입력해 접속하셔도 이전에 저장된 코드까지 함께 지워집니다. 학교 공용 기기에서는 체크하지 않도록 미리 안내해 주세요.

공약 실시 버튼이 회색으로 눌리지 않아요

아직 남은 도장이 목표에 못 미친 상태입니다. 목표만큼 모이면 버튼이 저절로 켜집니다. 공약을 실시하면 그만큼 도장이 차감되고, 학생들이 새로 받는 도장부터 다시 쌓입니다. (학생 개인의 도장 누계는 차감되지 않고 그대로 남습니다)

학생 이름을 고치면 그 학생이 다시 로그인해야 하나요?

아닙니다. 학생을 찾는 기준은 이름이 아니라 6자리 코드라서, 이름을 바꿔도 코드는 그대로이고 예전 제출물·피드백도 그대로 이어집니다. 제출물·피드백 시트와 드라이브의 학생 폴더 이름까지 함께 정리됩니다.

복사 버튼을 눌러도 반응이 없어요

버튼이 "⚠ 자동 복사 실패"로 바뀌면, 같은 카드의 코드 미리보기를 펼쳐서 안의 코드 상자를 클릭 → 전체 선택(Ctrl+A) → 복사(Ctrl+C)로 직접 복사해 주세요.

그 외 문제가 있어요

0단계에서 만들어 둔 시트 사본으로 되돌리신 뒤 다시 시도해 주세요. 그래도 안 되면 아래 인스타그램으로 연락 주세요.