app.v2.js

// v20260502c - soft delete sync fix
const CLOUD_ENV = "YOUR_CLOUD_ENV_ID";
let app = null;
let auth = null;
let db = null;
let currentUser = null;
let pendingVerifyOtp = null;
let pendingPhone = null;
let syncTimer = null;
try {
  if (typeof cloudbase !== "undefined") {
    app = cloudbase.init({ env: CLOUD_ENV, region: "ap-shanghai" });
    auth = app.auth();
    db = app.database();
  }
} catch (e) {
  console.warn("CloudBase 初始化失败，离线模式：", e);
}

const STORAGE_KEY = "todo-list-app-v2";
const COLLAPSED_STORAGE_KEY = `${STORAGE_KEY}-collapsed`;
const THEME_STORAGE_KEY = `${STORAGE_KEY}-theme`;
const SORT_MODE_STORAGE_KEY = `${STORAGE_KEY}-sort-mode`;
const ORDER_STORAGE_KEY = `${STORAGE_KEY}-order`;
const THEME_MEDIA_QUERY = "(prefers-color-scheme: dark)";
const TASK_TYPES = ["阅读", "输出", "实践", "事务", "其他"];
const SORT_MODES = ["default", "date-asc", "date-desc", "priority"];
const WEEKDAY_MAP = {
  一: 1,
  二: 2,
  三: 3,
  四: 4,
  五: 5,
  六: 6,
  日: 7,
  天: 7,
};
const DEFAULT_TASK_ORDER = {
  today: {},
  deadline: {},
  archive: {},
};
const DEFAULT_COLLAPSED_SECTIONS = {
  today: false,
  deadline: false,
  archive: false,
};

const form = document.querySelector("#task-form");
const formTitle = document.querySelector("#form-title");
const formSubtitle = document.querySelector("#form-subtitle");
const submitButton = document.querySelector("#submit-btn");
const cancelEditButton = document.querySelector("#cancel-edit-btn");
const titleInput = document.querySelector("#task-title");
const typeInput = document.querySelector("#task-type");
const scopeInput = document.querySelector("#task-scope");
const taskDateInput = document.querySelector("#task-date");
const dueDateInput = document.querySelector("#task-due-date");
const taskDateField = document.querySelector("#task-date-field");
const dueDateField = document.querySelector("#task-due-date-field");
const dateHelper = document.querySelector("#date-helper");
const urgentInput = document.querySelector("#task-urgent");
const importantInput = document.querySelector("#task-important");
const quadrantPreview = document.querySelector("#quadrant-preview");
const searchFilter = document.querySelector("#filter-search");
const statusFilter = document.querySelector("#filter-status");
const typeFilter = document.querySelector("#filter-type");
const quadrantFilter = document.querySelector("#filter-quadrant");
const sortModeInput = document.querySelector("#sort-mode");
const exportButton = document.querySelector("#export-btn");
const importFileInput = document.querySelector("#import-file");
const quickAddForm = document.querySelector("#quick-add-form");
const quickAddInput = document.querySelector("#quick-add-input");
const totalCount = document.querySelector("#total-count");
const todayCount = document.querySelector("#today-count");
const completedCount = document.querySelector("#completed-count");
const overdueCount = document.querySelector("#overdue-count");
const todayLabel = document.querySelector("#today-label");
const themeToggleButton = document.querySelector("#theme-toggle");
const todayTaskList = document.querySelector("#today-task-list");
const deadlineTaskList = document.querySelector("#deadline-task-list");
const archiveTaskList = document.querySelector("#archive-task-list");
const todaySectionCount = document.querySelector("#today-section-count");
const deadlineSectionCount = document.querySelector("#deadline-section-count");
const archiveSectionCount = document.querySelector("#archive-section-count");
const noResultsState = document.querySelector("#no-results-state");
const emptyState = document.querySelector("#empty-state");
const taskSections = document.querySelector(".task-sections");
const undoToast = document.querySelector("#undo-toast");
const undoToastMessage = document.querySelector("#undo-toast-message");
const undoToastAction = document.querySelector("#undo-toast-action");
const overdueStatCard = document.querySelector("#overdue-stat-card");
const loginToggle = document.querySelector("#login-toggle");
const loginModal = document.querySelector("#login-modal");
const loginPhone = document.querySelector("#login-phone");
const loginCode = document.querySelector("#login-code");
const sendCodeBtn = document.querySelector("#send-code-btn");
const loginSubmitBtn = document.querySelector("#login-submit-btn");
const loginCancelBtn = document.querySelector("#login-cancel-btn");
const loginError = document.querySelector("#login-error");

const state = {
  tasks: loadTasks(),
  editingTaskId: null,
  editingOriginalTask: null,
  filters: {
    search: "",
    status: "all",
    type: "all",
    quadrant: "all",
    tag: "all",
    overdueOnly: false,
  },
  sortMode: loadSortMode(),
  themePreference: loadThemePreference(),
  collapsedSections: loadCollapsedSections(),
  taskOrder: loadTaskOrder(),
  undo: {
    entry: null,
    timeoutId: null,
  },
  pendingDelete: {
    taskId: null,
    timeoutId: null,
  },
  searchDebounceId: null,
  login: {
    isLoggedIn: false,
    phone: "",
    userId: "",
  },
  drag: {
    taskId: null,
    sourceSectionKey: null,
    targetSectionKey: null,
    targetTaskId: null,
    position: null,
  },
  editingSubtasks: [],
};

function loadThemePreference() {
  try {
    const raw = localStorage.getItem(THEME_STORAGE_KEY);
    const parsed = raw ? JSON.parse(raw) : null;
    return parsed === "light" || parsed === "dark" ? parsed : null;
  } catch {
    return null;
  }
}

function loadSortMode() {
  try {
    const raw = localStorage.getItem(SORT_MODE_STORAGE_KEY);
    const parsed = raw ? JSON.parse(raw) : null;
    return SORT_MODES.includes(parsed) ? parsed : "default";
  } catch {
    return "default";
  }
}

function loadTaskOrder() {
  try {
    const raw = localStorage.getItem(ORDER_STORAGE_KEY);
    if (!raw) {
      return {
        today: {},
        deadline: {},
        archive: {},
      };
    }

    const parsed = JSON.parse(raw);
    return {
      today: normalizeOrderSection(parsed?.today),
      deadline: normalizeOrderSection(parsed?.deadline),
      archive: normalizeOrderSection(parsed?.archive),
    };
  } catch {
    return {
      today: {},
      deadline: {},
      archive: {},
    };
  }
}

function normalizeOrderSection(section) {
  if (!section || typeof section !== "object" || Array.isArray(section)) {
    return {};
  }

  return Object.fromEntries(
    Object.entries(section).filter(
      ([taskId, value]) => typeof taskId === "string" && Number.isFinite(value)
    )
  );
}

function getSystemThemePreference() {
  return window.matchMedia(THEME_MEDIA_QUERY).matches ? "dark" : "light";
}

function getResolvedTheme() {
  return state.themePreference || getSystemThemePreference();
}

function applyTheme(theme) {
  document.documentElement.dataset.theme = theme;

  if (!themeToggleButton) {
    return;
  }

  const isDark = theme === "dark";
  themeToggleButton.textContent = isDark ? "浅色模式" : "深色模式";
  themeToggleButton.setAttribute("aria-pressed", String(isDark));
  themeToggleButton.setAttribute("aria-label", isDark ? "切换到浅色模式" : "切换到深色模式");
}

function saveThemePreference(theme) {
  if (theme !== "light" && theme !== "dark") {
    return false;
  }

  return saveToLocalStorage(THEME_STORAGE_KEY, theme);
}

function saveSortMode(sortMode) {
  if (!SORT_MODES.includes(sortMode)) {
    return false;
  }

  return saveToLocalStorage(SORT_MODE_STORAGE_KEY, sortMode);
}

function handleThemeToggle() {
  const nextTheme = getResolvedTheme() === "dark" ? "light" : "dark";
  if (!saveThemePreference(nextTheme)) {
    applyTheme(getResolvedTheme());
    return;
  }

  state.themePreference = nextTheme;
  applyTheme(nextTheme);
}

function syncThemeWithSystem(event) {
  if (state.themePreference) {
    return;
  }

  applyTheme(event.matches ? "dark" : "light");
}

function createHighlightedTextFragment(text, keyword) {
  const fragment = document.createDocumentFragment();
  const normalizedKeyword = keyword.trim().toLowerCase();

  if (!normalizedKeyword) {
    fragment.append(text);
    return fragment;
  }

  const lowerText = text.toLowerCase();
  let searchStartIndex = 0;
  let matchIndex = lowerText.indexOf(normalizedKeyword, searchStartIndex);

  if (matchIndex === -1) {
    fragment.append(text);
    return fragment;
  }

  while (matchIndex !== -1) {
    if (matchIndex > searchStartIndex) {
      fragment.append(text.slice(searchStartIndex, matchIndex));
    }

    const mark = document.createElement("mark");
    mark.textContent = text.slice(matchIndex, matchIndex + normalizedKeyword.length);
    fragment.append(mark);

    searchStartIndex = matchIndex + normalizedKeyword.length;
    matchIndex = lowerText.indexOf(normalizedKeyword, searchStartIndex);
  }

  if (searchStartIndex < text.length) {
    fragment.append(text.slice(searchStartIndex));
  }

  return fragment;
}

function setElementTextWithHighlight(element, text) {
  element.textContent = "";
  element.append(createHighlightedTextFragment(text, state.filters.search));
}

function getTaskDateValue(task) {
  return task.scope === "deadline" ? task.dueDate || "9999-12-31" : task.taskDate || "9999-12-31";
}

function getPriorityWeight(task) {
  if (task.urgent && task.important) return 0;
  if (!task.urgent && task.important) return 1;
  if (task.urgent && !task.important) return 2;
  return 3;
}

function compareByCreatedAtDesc(a, b) {
  return new Date(b.createdAt) - new Date(a.createdAt);
}

function compareByDate(a, b, direction = "asc") {
  const comparison = getTaskDateValue(a).localeCompare(getTaskDateValue(b));
  if (comparison !== 0) {
    return direction === "desc" ? -comparison : comparison;
  }

  return compareByCreatedAtDesc(a, b);
}

function compareByPriority(a, b) {
  const priorityComparison = getPriorityWeight(a) - getPriorityWeight(b);
  if (priorityComparison !== 0) {
    return priorityComparison;
  }

  if (a.completed !== b.completed) return Number(a.completed) - Number(b.completed);
  return compareByCreatedAtDesc(a, b);
}

function sortTasks(tasks, sectionKey) {
  if (state.sortMode === "date-asc") {
    tasks.sort((a, b) => compareByDate(a, b, "asc"));
    return;
  }

  if (state.sortMode === "date-desc") {
    tasks.sort((a, b) => compareByDate(a, b, "desc"));
    return;
  }

  if (state.sortMode === "priority") {
    tasks.sort(compareByPriority);
    return;
  }

  const orderMap = state.taskOrder[sectionKey] || {};
  if (Object.keys(orderMap).length > 0) {
    tasks.sort((a, b) => {
      const aInMap = a.id in orderMap;
      const bInMap = b.id in orderMap;
      if (aInMap && bInMap) return orderMap[a.id] - orderMap[b.id];
      if (!aInMap && !bInMap) return compareByCreatedAtDesc(a, b);
      return aInMap ? -1 : 1;
    });
    return;
  }

  if (sectionKey === "deadline") {
    tasks.sort(compareDeadlineTasks);
    return;
  }

  if (sectionKey === "archive") {
    tasks.sort((a, b) => b.taskDate.localeCompare(a.taskDate) || compareDailyTasks(a, b));
    return;
  }

  tasks.sort(compareDailyTasks);
}

function getFocusableTaskItems() {
  return Array.from(taskSections.querySelectorAll(".task-item"));
}

function focusAdjacentTaskItem(currentItem, direction) {
  const items = getFocusableTaskItems();
  const currentIndex = items.indexOf(currentItem);
  if (currentIndex === -1) {
    return;
  }

  const nextItem = items[currentIndex + direction];
  if (nextItem) {
    nextItem.focus();
  }
}

function createTaskId() {
  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
    return crypto.randomUUID();
  }

  return `task-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
}

function getTodayDateString() {
  return new Date().toLocaleDateString("sv-SE");
}

function formatDate(dateString) {
  if (!dateString) return "未设置";
  const date = new Date(`${dateString}T00:00:00`);
  return new Intl.DateTimeFormat("zh-CN", {
    year: "numeric",
    month: "long",
    day: "numeric",
  }).format(date);
}

function formatShortDate(dateString) {
  if (!dateString) return "无日期";
  const date = new Date(`${dateString}T00:00:00`);
  return new Intl.DateTimeFormat("zh-CN", {
    month: "numeric",
    day: "numeric",
    weekday: "short",
  }).format(date);
}


function getQuadrant(urgent, important) {
  if (urgent && important) return "紧急且重要";
  if (urgent && !important) return "紧急不重要";
  if (!urgent && important) return "重要不紧急";
  return "不紧急不重要";
}

function getQuadrantClass(label) {
  if (label === "紧急且重要") return "q1";
  if (label === "紧急不重要") return "q2";
  if (label === "重要不紧急") return "q3";
  return "q4";
}

function getQuadrantVisual(label) {
  if (label === "紧急且重要") return { icon: "●", shortLabel: "第一象限" };
  if (label === "紧急不重要") return { icon: "▲", shortLabel: "第二象限" };
  if (label === "重要不紧急") return { icon: "■", shortLabel: "第三象限" };
  return { icon: "◆", shortLabel: "第四象限" };
}

function normalizeTask(task) {
  const urgent = Boolean(task.urgent);
  const important = Boolean(task.important);
  const createdAt = task.createdAt || new Date().toISOString();
  const createdDate = task.createdDate || createdAt.slice(0, 10);
  const scope = task.scope === "deadline" ? "deadline" : "daily";
  const taskDate = scope === "daily" ? task.taskDate || createdDate : "";
  const dueDate = scope === "deadline" ? task.dueDate || "" : "";

  return {
    id: task.id || createTaskId(),
    title: typeof task.title === "string" ? task.title : "",
    type: TASK_TYPES.includes(task.type) ? task.type : "其他",
    urgent,
    important,
    quadrant: getQuadrant(urgent, important),
    completed: Boolean(task.completed),
    createdAt,
    createdDate,
    scope,
    taskDate,
    dueDate,
    subtasks: Array.isArray(task.subtasks)
      ? task.subtasks
          .filter((s) => s && typeof s.title === "string" && s.title.trim())
          .map((s) => ({
            id: s.id || createTaskId(),
            title: s.title.trim(),
            completed: Boolean(s.completed),
          }))
      : [],
    reminderAt: typeof task.reminderAt === "string" ? task.reminderAt : "",
    recurrence:
      task.recurrence && typeof task.recurrence === "object"
        ? {
            type: ["daily", "weekly", "monthly"].includes(task.recurrence.type) ? task.recurrence.type : "",
            interval: Number.isFinite(task.recurrence.interval) ? task.recurrence.interval : 1,
            weekdays: Array.isArray(task.recurrence.weekdays) ? task.recurrence.weekdays : [],
            endDate: typeof task.recurrence.endDate === "string" ? task.recurrence.endDate : "",
          }
        : { type: "", interval: 1, weekdays: [], endDate: "" },
    tags: Array.isArray(task.tags)
      ? [...new Set(task.tags.filter((t) => typeof t === "string" && t.trim()).map((t) => t.trim()))]
      : [],
    deleted: Boolean(task.deleted),
    deletedAt: typeof task.deletedAt === "string" ? task.deletedAt : "",
  };
}

function scheduleSync() {
  if (!state.login.isLoggedIn) return;
  if (syncTimer) clearTimeout(syncTimer);
  syncTimer = setTimeout(() => {
    pushToCloud();
  }, 1000);
}

async function pushToCloud() {
  if (!db || !currentUser) return;
  try {
    const userId = currentUser.id;
    const collection = db.collection("tasks");
    // 循环删除直到清空，避免 limit(1000) 导致残留
    let hasMore = true;
    while (hasMore) {
      const existing = await collection.where({ userId }).limit(1000).get();
      const docs = existing.data || [];
      if (docs.length === 0) {
        hasMore = false;
      } else {
        await Promise.all(docs.map((doc) => collection.doc(doc._id).remove()));
        if (docs.length < 1000) hasMore = false;
      }
    }
    // 只推送未删除的任务，已删除的不再上传
    var activeTasks = state.tasks.filter(function (t) { return !t.deleted; });
    await Promise.all(
      activeTasks.map((task) => collection.add({ ...task, userId }))
    );
    localStorage.setItem(STORAGE_KEY + '-cloud-synced', '1');
  } catch (e) {
    console.warn("推送到云端失败：", e);
  }
}

async function syncFromCloud() {
  if (!db || !currentUser) return;
  try {
    const userId = currentUser.id;
    const result = await db.collection("tasks").where({ userId }).limit(1000).get();
    const cloudTasks = (result.data || [])
      .map(({ _id, userId, ...task }) => normalizeTask(task))
      .filter((t) => t.title.trim() && !t.deleted);

    const hasEverSynced = localStorage.getItem(STORAGE_KEY + '-cloud-synced');

    if (cloudTasks.length === 0) {
      if (hasEverSynced) {
        // 云端曾有数据但现在为空 = 所有任务已被删除，清空本地
        if (state.tasks.length > 0) {
          commitTasks([]);
          render();
        }
      } else {
        // 从未同步过 = 首次使用，把本地数据推上去
        if (state.tasks.filter((t) => !t.deleted).length > 0) {
          await pushToCloud();
          localStorage.setItem(STORAGE_KEY + '-cloud-synced', '1');
        }
      }
      return;
    }

    // 云端有数据：直接用云端覆盖本地
    localStorage.setItem(STORAGE_KEY + '-cloud-synced', '1');
    if (!commitTasks(cloudTasks)) return;
    render();
  } catch (e) {
    console.warn("从云端同步失败：", e);
  }
}

function showLoginError(msg) {
  loginError.textContent = msg;
  loginError.hidden = false;
}

function clearLoginError() {
  loginError.hidden = true;
  loginError.textContent = "";
}

function openLoginModal() {
  clearLoginError();
  loginPhone.value = "";
  loginCode.value = "";
  loginModal.hidden = false;
  loginPhone.focus();
}

function closeLoginModal() {
  loginModal.hidden = true;
  clearLoginError();
}

function updateLoginUI() {
  if (state.login.isLoggedIn) {
    const maskedPhone = state.login.phone.replace(/(\d{3})\d{4}(\d{4})/, "$1****$2");
    loginToggle.textContent = maskedPhone + " 退出";
    loginToggle.setAttribute("aria-label", "点击退出登录");
  } else {
    loginToggle.textContent = "登录同步";
    loginToggle.setAttribute("aria-label", "点击登录以同步数据");
  }
}

async function handleLogout() {
  if (!window.confirm("确定要退出登录吗？退出后数据仅保存在本地。")) return;
  try {
    if (auth) await auth.signOut();
  } catch (e) {
    console.warn("CloudBase 退出失败：", e);
  }
  if (syncTimer) {
    clearTimeout(syncTimer);
    syncTimer = null;
  }
  currentUser = null;
  pendingVerifyOtp = null;
  pendingPhone = null;
  state.login.isLoggedIn = false;
  state.login.phone = "";
  state.login.userId = "";
  updateLoginUI();
}

async function sendVerificationCode() {
  const phone = loginPhone.value.trim();
  if (!/^1\d{10}$/.test(phone)) {
    showLoginError("请输入正确的11位手机号");
    return;
  }
  if (!auth) {
    showLoginError("CloudBase 未初始化，请检查网络后刷新");
    return;
  }

  try {
    sendCodeBtn.disabled = true;
    sendCodeBtn.textContent = "发送中...";
    const { data, error } = await auth.signInWithOtp({ phone });
    if (error) {
      throw new Error(error.message || "验证码发送失败");
    }
    // 保存 verifyOtp 回调和手机号，登录时使用
    pendingVerifyOtp = data.verifyOtp;
    pendingPhone = phone;

    let seconds = 60;
    const tick = () => {
      seconds--;
      sendCodeBtn.textContent = seconds > 0 ? `${seconds}s` : "发送验证码";
      if (seconds > 0) {
        setTimeout(tick, 1000);
      } else {
        sendCodeBtn.disabled = false;
      }
    };
    setTimeout(tick, 1000);
  } catch (e) {
    sendCodeBtn.textContent = "发送验证码";
    sendCodeBtn.disabled = false;
    showLoginError("发送失败：" + (e.message || "请重试"));
  }
}

async function handleLogin() {
  const phone = loginPhone.value.trim();
  const code = loginCode.value.trim();

  if (!/^1\d{10}$/.test(phone)) {
    showLoginError("请输入正确的11位手机号");
    return;
  }
  if (!/^\d{4,6}$/.test(code)) {
    showLoginError("请输入4-6位验证码");
    return;
  }
  if (!auth) {
    showLoginError("CloudBase 未初始化，请检查网络后刷新");
    return;
  }
  if (!pendingVerifyOtp) {
    showLoginError("请先发送验证码");
    return;
  }

  try {
    loginSubmitBtn.disabled = true;
    loginSubmitBtn.textContent = "登录中...";

    let loginData = null;
    let loginError = null;
    let debugInfo = [];

    // 方式1：使用 signInWithOtp 返回的 verifyOtp 闭包（主流浏览器兼容）
    if (pendingVerifyOtp) {
      debugInfo.push("闭包存在");
      try {
        const result = await pendingVerifyOtp({ token: code });
        loginData = result.data;
        loginError = result.error;
        debugInfo.push("闭包结果: data=" + !!loginData + " error=" + JSON.stringify(loginError));
      } catch (closureErr) {
        console.warn("verifyOtp 闭包调用失败，尝试 fallback：", closureErr);
        loginError = closureErr;
        debugInfo.push("闭包异常: " + (closureErr.message || String(closureErr)));
      }
    } else {
      debugInfo.push("闭包不存在");
    }

    // 方式2：fallback - 通过 resend 获取 messageId，再用 auth.verifyOtp 独立方法验证
    if ((!loginData || loginError) && auth.verifyOtp && pendingPhone) {
      debugInfo.push("尝试fallback");
      try {
        const { data: resendData, error: resendErr } = await auth.resend({
          phone: pendingPhone,
          type: "sms",
        });
        debugInfo.push("resend: err=" + JSON.stringify(resendErr) + " data=" + JSON.stringify(resendData));
        if (!resendErr && resendData && resendData.messageId) {
          const result = await auth.verifyOtp({
            phone: pendingPhone,
            token: code,
            messageId: resendData.messageId,
          });
          loginData = result.data;
          loginError = result.error;
          debugInfo.push("fallback结果: data=" + !!loginData + " error=" + JSON.stringify(loginError));
        }
      } catch (fallbackErr) {
        console.warn("verifyOtp fallback 也失败：", fallbackErr);
        debugInfo.push("fallback异常: " + (fallbackErr.message || String(fallbackErr)));
        if (!loginError) loginError = fallbackErr;
      }
    } else if (!loginData || loginError) {
      debugInfo.push("无法fallback: verifyOtp=" + !!auth.verifyOtp + " phone=" + !!pendingPhone);
    }

    if (loginError || !loginData) {
      throw new Error((loginError?.message || "登录失败") + " [" + debugInfo.join(" | ") + "]");
    }

    currentUser = loginData.user || null;
    state.login.isLoggedIn = true;
    state.login.phone = phone;
    state.login.userId = currentUser ? currentUser.id : "";
    pendingVerifyOtp = null;
    pendingPhone = null;

    updateLoginUI();
    closeLoginModal();
    await syncFromCloud();
  } catch (e) {
    showLoginError("登录失败：" + (e.message || JSON.stringify(e) || "请重试") + " [" + typeof e + "]");
  } finally {
    loginSubmitBtn.disabled = false;
    loginSubmitBtn.textContent = "登录";
  }
}

async function checkLoginState() {
  if (!auth) return;
  try {
    const { data, error } = await auth.getSession();
    if (error || !data || !data.user) return;
    currentUser = data.user;
    state.login.isLoggedIn = true;
    state.login.userId = currentUser.id;
    const rawPhone = currentUser.phone || "";
    state.login.phone = rawPhone.replace(/^\+86\s*/, "");
    updateLoginUI();
    await syncFromCloud();
  } catch (e) {
    // not logged in, normal
  }
}

function loadTasks() {
  try {
    const raw = localStorage.getItem(STORAGE_KEY) || localStorage.getItem("todo-list-app-v1");
    if (!raw) return [];

    const parsed = JSON.parse(raw);
    if (!Array.isArray(parsed)) return [];

    return parsed.map(normalizeTask).filter((task) => task.title.trim());
  } catch {
    return [];
  }
}

function loadCollapsedSections() {
  try {
    const raw = localStorage.getItem(COLLAPSED_STORAGE_KEY);
    if (!raw) return { ...DEFAULT_COLLAPSED_SECTIONS };

    const parsed = JSON.parse(raw);
    return {
      today: Boolean(parsed?.today),
      deadline: Boolean(parsed?.deadline),
      archive: Boolean(parsed?.archive),
    };
  } catch {
    return { ...DEFAULT_COLLAPSED_SECTIONS };
  }
}

function saveToLocalStorage(key, value) {
  try {
    localStorage.setItem(key, JSON.stringify(value));
    return true;
  } catch {
    window.alert("保存失败，请清理浏览器存储空间后重试。");
    return false;
  }
}

function saveTasks() {
  return saveToLocalStorage(STORAGE_KEY, state.tasks);
}

function saveCollapsedSections() {
  return saveToLocalStorage(COLLAPSED_STORAGE_KEY, state.collapsedSections);
}

function commitTasks(nextTasks) {
  const previousTasks = state.tasks;
  state.tasks = nextTasks;

  if (saveTasks()) {
    scheduleSync();
    return true;
  }

  state.tasks = previousTasks;
  return false;
}

function isTaskOverdue(task) {
  const today = getTodayDateString();
  return task.scope === "deadline" && Boolean(task.dueDate) && task.dueDate < today && !task.completed;
}

function buildSearchText(task) {
  return [
    task.title,
    task.type,
    task.quadrant,
    task.scope === "daily" ? "当日任务" : "截止任务",
    task.taskDate,
    task.dueDate,
    formatDate(task.taskDate),
    formatDate(task.dueDate),
    formatShortDate(task.taskDate),
    formatShortDate(task.dueDate),
    ...task.tags,
  ]
    .filter(Boolean)
    .join(" ")
    .toLowerCase();
}

function matchesFilters(task) {
  if (task.deleted) return false;

  const searchKeyword = state.filters.search.trim().toLowerCase();
  if (searchKeyword && !buildSearchText(task).includes(searchKeyword)) {
    return false;
  }

  if (state.filters.status === "completed" && !task.completed) {
    return false;
  }

  if (state.filters.status === "active" && task.completed) {
    return false;
  }

  if (state.filters.type !== "all" && task.type !== state.filters.type) {
    return false;
  }

  if (state.filters.quadrant !== "all" && task.quadrant !== state.filters.quadrant) {
    return false;
  }

  if (state.filters.tag !== "all" && !task.tags.includes(state.filters.tag)) {
    return false;
  }

  if (state.filters.overdueOnly && !isTaskOverdue(task)) {
    return false;
  }

  return true;
}

function compareDailyTasks(a, b) {
  if (a.completed !== b.completed) return Number(a.completed) - Number(b.completed);
  return new Date(b.createdAt) - new Date(a.createdAt);
}

function compareDeadlineTasks(a, b) {
  if (a.completed !== b.completed) return Number(a.completed) - Number(b.completed);
  if (a.dueDate && b.dueDate && a.dueDate !== b.dueDate) return a.dueDate.localeCompare(b.dueDate);
  if (a.dueDate && !b.dueDate) return -1;
  if (!a.dueDate && b.dueDate) return 1;
  return new Date(b.createdAt) - new Date(a.createdAt);
}

function getVisibleTaskGroups() {
  const today = getTodayDateString();
  const groups = {
    todayTasks: [],
    deadlineTasks: [],
    archiveTasks: [],
  };

  state.tasks.forEach((task) => {
    if (!matchesFilters(task)) {
      return;
    }

    if (task.scope === "deadline") {
      groups.deadlineTasks.push(task);
      return;
    }

    if (task.taskDate === today) {
      groups.todayTasks.push(task);
      return;
    }

    groups.archiveTasks.push(task);
  });

  sortTasks(groups.todayTasks, "today");
  sortTasks(groups.deadlineTasks, "deadline");
  sortTasks(groups.archiveTasks, "archive");

  return groups;
}

function updateStats() {
  const today = getTodayDateString();
  const activeTasks = state.tasks.filter((task) => !task.deleted);
  const completed = activeTasks.filter((task) => task.completed).length;
  const todayPending = activeTasks.filter(
    (task) => task.scope === "daily" && task.taskDate === today && !task.completed
  ).length;
  const overdue = activeTasks.filter(isTaskOverdue).length;

  totalCount.textContent = String(activeTasks.length);
  todayCount.textContent = String(todayPending);
  completedCount.textContent = String(completed);
  overdueCount.textContent = String(overdue);
  overdueStatCard?.setAttribute("aria-pressed", String(state.filters.overdueOnly));
  todayLabel.textContent = `今天是 ${formatDate(today)}`;
}

function createBadge(text, className) {
  const badge = document.createElement("span");
  badge.className = className;
  badge.textContent = text;
  return badge;
}

function createQuadrantBadge(label) {
  const visual = getQuadrantVisual(label);
  const badge = document.createElement("span");
  badge.className = `badge quadrant ${getQuadrantClass(label)}`;

  const icon = document.createElement("span");
  icon.className = "badge-icon";
  icon.textContent = visual.icon;

  const text = document.createElement("span");
  text.textContent = `${visual.shortLabel} · ${label}`;

  badge.append(icon, text);
  return badge;
}

function createTaskItem(task) {
  const item = document.createElement("li");
  item.className = `task-item ${getQuadrantClass(task.quadrant)}${task.completed ? " completed" : ""}`;
  item.dataset.id = task.id;
  item.tabIndex = 0;

  if (isTaskOverdue(task)) {
    item.classList.add("overdue");
  }

  const checkbox = document.createElement("input");
  checkbox.className = "task-toggle";
  checkbox.type = "checkbox";
  checkbox.checked = task.completed;
  checkbox.setAttribute("aria-label", `完成任务：${task.title}`);

  const main = document.createElement("div");
  main.className = "task-main";

  const topRow = document.createElement("div");
  topRow.className = "task-top-row";

  const title = document.createElement("div");
  title.className = "task-title";
  setElementTextWithHighlight(title, task.title);

  const dateTextValue = task.scope === "daily"
    ? `任务日期 · ${formatShortDate(task.taskDate)}`
    : task.dueDate
      ? `截止日期 · ${formatShortDate(task.dueDate)}`
      : "截止日期 · 未设置";
  const dateText = document.createElement("div");
  dateText.className = "task-date-text";
  setElementTextWithHighlight(dateText, dateTextValue);

  topRow.append(title, dateText);

  const metaRow = document.createElement("div");
  metaRow.className = "meta-row";
  metaRow.append(
    createBadge(task.type, "badge type"),
    createBadge(task.scope === "daily" ? "当日任务" : "截止任务", "badge scope"),
    createQuadrantBadge(task.quadrant)
  );
  if (task.reminderAt) {
    metaRow.append(createBadge("⏰ 已设提醒", "badge reminder"));
  }
  if (task.recurrence && task.recurrence.type) {
    const recLabels = { daily: "每天", weekly: "每周", monthly: "每月" };
    metaRow.append(createBadge("🔁 " + (recLabels[task.recurrence.type] || ""), "badge recurrence"));
  }
  task.tags.forEach((tag) => {
    metaRow.append(createBadge("#" + tag, "badge tag"));
  });

  // 子任务进度条
  const subtaskRow = document.createElement("div");
  subtaskRow.className = "subtask-progress";
  if (task.subtasks.length > 0) {
    const done = task.subtasks.filter((s) => s.completed).length;
    const total = task.subtasks.length;
    const pct = Math.round((done / total) * 100);

    const bar = document.createElement("div");
    bar.className = "subtask-bar";
    const fill = document.createElement("div");
    fill.className = "subtask-bar-fill";
    fill.style.width = pct + "%";
    bar.append(fill);

    const label = document.createElement("span");
    label.className = "subtask-label";
    label.textContent = done === total ? `全部完成 (${done}/${total})` : `${done}/${total} 已完成`;

    subtaskRow.append(bar, label);
  }

  // 子任务列表
  const subtaskList = document.createElement("ul");
  subtaskList.className = "subtask-list";
  task.subtasks.forEach((sub) => {
    const li = document.createElement("li");
    li.className = "subtask-item" + (sub.completed ? " completed" : "");

    const cb = document.createElement("input");
    cb.type = "checkbox";
    cb.checked = sub.completed;
    cb.className = "subtask-toggle";
    cb.dataset.subtaskId = sub.id;
    cb.setAttribute("aria-label", `完成子任务：${sub.title}`);

    const span = document.createElement("span");
    span.className = "subtask-title";
    span.textContent = sub.title;

    li.append(cb, span);
    subtaskList.append(li);
  });

  const status = document.createElement("div");
  status.className = "status-text";
  const statusTextValue = task.completed
    ? `已完成 · 创建于 ${formatShortDate(task.createdDate)}`
    : `进行中 · 创建于 ${formatShortDate(task.createdDate)}`;
  setElementTextWithHighlight(status, statusTextValue);

  main.append(topRow, metaRow, subtaskRow, subtaskList, status);

  const actions = document.createElement("div");
  actions.className = "task-actions";

  const editButton = document.createElement("button");
  editButton.className = "secondary-btn edit-btn";
  editButton.type = "button";
  editButton.textContent = "编辑";
  editButton.setAttribute("aria-label", `编辑任务：${task.title}`);

  const isPendingDelete = state.pendingDelete.taskId === task.id;
  const deleteButton = document.createElement("button");
  deleteButton.className = isPendingDelete ? "delete-btn confirm-delete-btn" : "delete-btn";
  deleteButton.type = "button";
  deleteButton.textContent = isPendingDelete ? "确认删除" : "删除";
  deleteButton.setAttribute("aria-label", `${isPendingDelete ? "确认删除任务" : "删除任务"}：${task.title}`);

  actions.append(editButton, deleteButton);

  const dragHandle = document.createElement("span");
  dragHandle.className = "drag-handle";
  dragHandle.setAttribute("draggable", "true");
  dragHandle.setAttribute("aria-hidden", "true");
  dragHandle.textContent = "⠿";

  item.append(dragHandle, checkbox, main, actions);
  return item;
}

function getTaskSectionKey(task) {
  const today = getTodayDateString();
  if (task.scope === "deadline") return "deadline";
  return task.taskDate === today ? "today" : "archive";
}

function getTaskListElement(sectionKey) {
  if (sectionKey === "today") return todayTaskList;
  if (sectionKey === "deadline") return deadlineTaskList;
  return archiveTaskList;
}

function renderTaskList(listElement, tasks, emptyText) {
  listElement.innerHTML = "";

  if (!tasks.length) {
    const empty = document.createElement("li");
    empty.className = "empty-state";
    empty.textContent = emptyText;
    listElement.append(empty);
    return;
  }

  tasks.forEach((task) => {
    listElement.append(createTaskItem(task));
  });
}

function replaceTaskItem(taskId, shouldAnimateCompletion = false) {
  if (state.sortMode !== "default" || state.filters.status !== "all" || state.filters.overdueOnly) {
    renderLists();
    return null;
  }

  const task = state.tasks.find((item) => item.id === taskId);
  if (!task || !matchesFilters(task)) {
    renderLists();
    return null;
  }

  const existingItem = taskSections.querySelector(`.task-item[data-id="${taskId}"]`);
  if (!existingItem) {
    renderLists();
    return null;
  }

  const sectionKey = getTaskSectionKey(task);
  const listElement = getTaskListElement(sectionKey);
  const { todayTasks, deadlineTasks, archiveTasks } = getVisibleTaskGroups();
  const sectionTasks =
    sectionKey === "today" ? todayTasks : sectionKey === "deadline" ? deadlineTasks : archiveTasks;
  const nextTaskIndex = sectionTasks.findIndex((item) => item.id === taskId);

  if (nextTaskIndex === -1) {
    renderLists();
    return null;
  }

  const nextItem = createTaskItem(task);
  existingItem.remove();

  const nextTask = sectionTasks[nextTaskIndex + 1];
  const referenceNode = nextTask ? listElement.querySelector(`.task-item[data-id="${nextTask.id}"]`) : null;
  listElement.insertBefore(nextItem, referenceNode);

  if (shouldAnimateCompletion) {
    nextItem.classList.add("completing");
    window.setTimeout(() => {
      nextItem.classList.remove("completing");
    }, 550);
  }

  return nextItem;
}

function syncSectionStates() {
  document.querySelectorAll(".task-section").forEach((section) => {
    const sectionKey = section.dataset.section;
    const isCollapsed = Boolean(state.collapsedSections[sectionKey]);
    const toggle = section.querySelector(".section-toggle");

    section.classList.toggle("collapsed", isCollapsed);
    if (toggle) {
      toggle.setAttribute("aria-expanded", String(!isCollapsed));
    }
  });
}

function setOverdueFilter(enabled) {
  state.filters.overdueOnly = enabled;
  render();
}

function scrollToTask(taskId) {
  requestAnimationFrame(() => {
    const el = taskSections.querySelector(`.task-item[data-id="${taskId}"]`);
    if (el) {
      el.scrollIntoView({ behavior: "smooth", block: "nearest" });
      el.focus();
    }
  });
}

function hasActiveFilters() {
  return Boolean(
    state.filters.search.trim() ||
    state.filters.status !== "all" ||
    state.filters.type !== "all" ||
    state.filters.quadrant !== "all" ||
    state.filters.tag !== "all" ||
    state.filters.overdueOnly
  );
}

function renderLists() {
  // 动态填充标签筛选选项
  const tagFilterEl = document.querySelector("#filter-tag");
  if (tagFilterEl) {
    const allTags = [...new Set(state.tasks.flatMap((t) => t.tags))].sort();
    const currentTagValue = tagFilterEl.value;
    tagFilterEl.innerHTML = '<option value="all">全部</option>';
    allTags.forEach((tag) => {
      const opt = document.createElement("option");
      opt.value = tag;
      opt.textContent = "#" + tag;
      tagFilterEl.append(opt);
    });
    tagFilterEl.value = allTags.includes(currentTagValue) || currentTagValue === "all" ? currentTagValue : "all";
  }

  const { todayTasks, deadlineTasks, archiveTasks } = getVisibleTaskGroups();
  const visibleTaskCount = todayTasks.length + deadlineTasks.length + archiveTasks.length;
  const hasTasks = state.tasks.length > 0;
  const showGlobalEmptyState = visibleTaskCount === 0 && hasActiveFilters();
  const showEmptyState = !hasTasks;

  todaySectionCount.textContent = String(todayTasks.length);
  deadlineSectionCount.textContent = String(deadlineTasks.length);
  archiveSectionCount.textContent = String(archiveTasks.length);

  emptyState.hidden = true;
  noResultsState.hidden = showEmptyState || !showGlobalEmptyState;
  taskSections.hidden = false;

  if (showEmptyState) {
    todayTaskList.innerHTML = "";
    deadlineTaskList.innerHTML = "";
    archiveTaskList.innerHTML = "";
  } else if (showGlobalEmptyState) {
    todayTaskList.innerHTML = "";
    deadlineTaskList.innerHTML = "";
    archiveTaskList.innerHTML = "";
  } else {
    renderTaskList(todayTaskList, todayTasks, "今天没有符合条件的当日任务。");
    renderTaskList(deadlineTaskList, deadlineTasks, "当前没有符合条件的截止任务。");
    renderTaskList(archiveTaskList, archiveTasks, "暂时没有可查看的归档任务。");
  }

  syncSectionStates();
}

function renderQuadrantPreview() {
  const label = getQuadrant(urgentInput.checked, importantInput.checked);
  const visual = getQuadrantVisual(label);
  quadrantPreview.textContent = `${visual.icon} ${label}`;
}

function syncDateFields() {
  const isDaily = scopeInput.value === "daily";
  const originalTask = state.editingOriginalTask;

  taskDateField.hidden = !isDaily;
  dueDateField.hidden = isDaily;
  taskDateInput.required = isDaily;
  dueDateInput.required = !isDaily;

  if (isDaily) {
    taskDateInput.value ||= originalTask?.taskDate || getTodayDateString();
    dateHelper.textContent = "当日任务会按任务日期进入今日清单，其他日期的当日任务会进入归档区。";
  } else {
    dueDateInput.value ||= originalTask?.dueDate || getTodayDateString();
    dateHelper.textContent = "截止任务不会归档，会按截止日期排序，逾期任务会高亮显示。";
  }
}

function syncDragEnabled() {
  taskSections.classList.toggle("drag-enabled", state.sortMode === "default");
}

function render() {
  updateStats();
  renderLists();
  renderQuadrantPreview();
  syncDateFields();
  syncDragEnabled();
}

function populateForm(task) {
  titleInput.value = task.title;
  typeInput.value = task.type;
  scopeInput.value = task.scope;
  urgentInput.checked = task.urgent;
  importantInput.checked = task.important;
  taskDateInput.value = task.taskDate || "";
  dueDateInput.value = task.dueDate || "";
  syncDateFields();
  renderQuadrantPreview();
  state.editingSubtasks = (task.subtasks || []).map((s) => ({ ...s }));
  renderSubtaskEditList();
  const reminderSel = document.querySelector("#task-reminder");
  if (reminderSel) {
    if (!task.reminderAt) {
      reminderSel.value = "";
    } else if (task.reminderAt.endsWith("T09:00:00")) {
      reminderSel.value = "at-time";
    } else if (task.reminderAt.endsWith("T08:00:00")) {
      reminderSel.value = "1h-before";
    } else {
      reminderSel.value = "1d-before";
    }
  }
  const recSel = document.querySelector("#task-recurrence-type");
  if (recSel) recSel.value = task.recurrence?.type || "";
}

function startEditing(taskId) {
  const task = state.tasks.find((item) => item.id === taskId);
  if (!task) return;

  clearPendingDelete(true);
  state.editingTaskId = taskId;
  state.editingOriginalTask = { ...task };
  formTitle.textContent = "编辑任务";
  formSubtitle.textContent = "可以修改标题、类型、日期和优先级。";
  submitButton.textContent = "保存修改";
  cancelEditButton.hidden = false;
  populateForm(task);

  // 展开手动添加面板（如果处于折叠状态）
  if (composerToggle && composerBody) {
    var isCollapsed = composerToggle.getAttribute("aria-expanded") !== "true";
    if (isCollapsed) {
      composerToggle.setAttribute("aria-expanded", "true");
      composerBody.hidden = false;
    }
  }

  titleInput.focus();
  form.scrollIntoView({ behavior: "smooth", block: "center" });
}

function stopEditing() {
  state.editingTaskId = null;
  state.editingOriginalTask = null;
  formTitle.textContent = "添加任务";
  formSubtitle.textContent = "支持创建“当日任务”和“截止任务”。";
  submitButton.textContent = "添加任务";
  cancelEditButton.hidden = true;
  resetForm();
}

function buildTaskFromForm(existingTask = {}) {
  const title = titleInput.value.trim();
  if (!title) return null;

  const urgent = urgentInput.checked;
  const important = importantInput.checked;
  const scope = scopeInput.value;
  const createdAt = existingTask.createdAt || new Date().toISOString();
  const createdDate = existingTask.createdDate || getTodayDateString();

  return {
    id: existingTask.id || createTaskId(),
    title,
    type: typeInput.value,
    urgent,
    important,
    quadrant: getQuadrant(urgent, important),
    completed: Boolean(existingTask.completed),
    createdAt,
    createdDate,
    scope,
    taskDate: scope === "daily" ? taskDateInput.value || createdDate : "",
    dueDate: scope === "deadline" ? dueDateInput.value || createdDate : "",
    subtasks: state.editingSubtasks.map((s) => ({ ...s })),
    reminderAt: (function () {
      const sel = document.querySelector("#task-reminder");
      if (!sel || !sel.value) return "";
      const baseDate = scope === "deadline" ? dueDateInput.value : taskDateInput.value;
      if (!baseDate) return "";
      if (sel.value === "at-time") return baseDate + "T09:00:00";
      if (sel.value === "1d-before") {
        const d = new Date(baseDate + "T09:00:00");
        d.setDate(d.getDate() - 1);
        return d.toISOString().slice(0, 19);
      }
      if (sel.value === "1h-before" && scope === "deadline") return baseDate + "T08:00:00";
      return "";
    })(),
    recurrence: (function () {
      const sel = document.querySelector("#task-recurrence-type");
      return {
        type: sel ? sel.value : "",
        interval: 1,
        weekdays: [],
        endDate: "",
      };
    })(),
    tags: existingTask.tags || [],
  };
}

function clearUndoState() {
  if (state.undo.timeoutId) {
    clearTimeout(state.undo.timeoutId);
  }

  state.undo.entry = null;
  state.undo.timeoutId = null;
  undoToast.hidden = true;
  undoToastMessage.textContent = "";
}

function showUndoToast(message, entry) {
  clearUndoState();
  state.undo.entry = entry;
  undoToastMessage.textContent = message;
  undoToast.hidden = false;
  state.undo.timeoutId = window.setTimeout(() => {
    clearUndoState();
  }, 3000);
}

function handleUndo() {
  const entry = state.undo.entry;
  if (!entry) return;

  if (entry.type === "delete") {
    // 撤销软删除：移除 deleted 标记
    const nextTasks = state.tasks.map((task) => {
      if (task.id !== entry.task.id) return task;
      var copy = {};
      for (var k in task) copy[k] = task[k];
      delete copy.deleted;
      delete copy.deletedAt;
      return copy;
    });
    if (!commitTasks(nextTasks)) return;
  }

  if (entry.type === "toggle") {
    const hasTask = state.tasks.some((task) => task.id === entry.taskId);
    if (!hasTask) {
      clearUndoState();
      return;
    }

    const nextTasks = state.tasks.map((task) =>
      task.id === entry.taskId ? { ...task, completed: entry.previousCompleted } : task
    );

    if (!commitTasks(nextTasks)) return;
  }

  clearUndoState();
  render();
}

function clearPendingDelete(shouldRender = false) {
  const hadPendingDelete = Boolean(state.pendingDelete.taskId);

  if (state.pendingDelete.timeoutId) {
    clearTimeout(state.pendingDelete.timeoutId);
  }

  state.pendingDelete.taskId = null;
  state.pendingDelete.timeoutId = null;

  if (shouldRender && hadPendingDelete) {
    renderLists();
  }
}

function startPendingDelete(taskId) {
  clearPendingDelete(false);
  state.pendingDelete.taskId = taskId;
  state.pendingDelete.timeoutId = window.setTimeout(() => {
    clearPendingDelete(true);
  }, 2000);
  renderLists();
}

function addTask(event) {
  event.preventDefault();

  const nextTask = buildTaskFromForm();
  if (!nextTask) return;

  if (!commitTasks([nextTask, ...state.tasks])) return;

  clearPendingDelete(false);

  // 确保新任务所在的分区是展开的
  var sectionKey = getTaskSectionKey(nextTask);
  if (state.collapsedSections[sectionKey]) {
    state.collapsedSections[sectionKey] = false;
    saveCollapsedSections();
  }

  if (state.sortMode === "default" && !hasActiveFilters()) {
    updateStats();
    var listElement = getTaskListElement(sectionKey);
    var newItem = createTaskItem(nextTask);
    // 隐藏空状态，显示任务列表容器
    emptyState.hidden = true;
    noResultsState.hidden = true;
    taskSections.hidden = false;
    // 清除该分区的空状态占位
    var emptyLi = listElement.querySelector('.empty-state');
    if (emptyLi) emptyLi.remove();
    listElement.prepend(newItem);
    syncSectionStates();
    var groups = getVisibleTaskGroups();
    todaySectionCount.textContent = String(groups.todayTasks.length);
    deadlineSectionCount.textContent = String(groups.deadlineTasks.length);
    archiveSectionCount.textContent = String(groups.archiveTasks.length);
  } else {
    render();
  }

  scrollToTask(nextTask.id);
  resetForm();
}

function updateTask(event) {
  event.preventDefault();

  const existingTask = state.tasks.find((task) => task.id === state.editingTaskId);
  if (!existingTask) {
    stopEditing();
    return;
  }

  const nextTask = buildTaskFromForm(existingTask);
  if (!nextTask) return;

  if (!commitTasks(state.tasks.map((task) => (task.id === existingTask.id ? nextTask : task)))) return;

  var editedTaskId = nextTask.id;
  stopEditing();
  render();
  scrollToTask(editedTaskId);
}

function handleSubmit(event) {
  if (state.editingTaskId) {
    updateTask(event);
    return;
  }

  addTask(event);
}

function resetForm() {
  titleInput.value = "";
  typeInput.value = "其他";
  scopeInput.value = "daily";
  taskDateInput.value = getTodayDateString();
  dueDateInput.value = "";
  urgentInput.checked = false;
  importantInput.checked = false;
  syncDateFields();
  renderQuadrantPreview();
  state.editingSubtasks = [];
  renderSubtaskEditList();
  const reminderSel = document.querySelector("#task-reminder");
  if (reminderSel) reminderSel.value = "";
  const recSel = document.querySelector("#task-recurrence-type");
  if (recSel) recSel.value = "";
  titleInput.focus();
}

function parseQuickAdd(rawText) {
  const text = rawText.trim();
  if (!text) return null;

  let remaining = text;

  function strip(matched) {
    remaining = remaining.replace(matched, "").replace(/\s+/g, " ").trim();
  }

  const today = new Date();
  today.setHours(0, 0, 0, 0);
  let resolvedDate = null;
  let dateMatch;

  if ((dateMatch = remaining.match(/大后天/))) {
    const d = new Date(today);
    d.setDate(d.getDate() + 3);
    resolvedDate = d;
    strip(dateMatch[0]);
  } else if ((dateMatch = remaining.match(/后天/))) {
    const d = new Date(today);
    d.setDate(d.getDate() + 2);
    resolvedDate = d;
    strip(dateMatch[0]);
  } else if ((dateMatch = remaining.match(/明天/))) {
    const d = new Date(today);
    d.setDate(d.getDate() + 1);
    resolvedDate = d;
    strip(dateMatch[0]);
  } else if ((dateMatch = remaining.match(/今天/))) {
    resolvedDate = new Date(today);
    strip(dateMatch[0]);
  } else if ((dateMatch = remaining.match(/下(周|星期)([一二三四五六日天])/))) {
    const targetIso = WEEKDAY_MAP[dateMatch[2]];
    const currentIso = today.getDay() || 7;
    const daysToNextMonday = (8 - currentIso) % 7 || 7;
    const d = new Date(today);
    d.setDate(d.getDate() + daysToNextMonday + (targetIso - 1));
    resolvedDate = d;
    strip(dateMatch[0]);
  } else if ((dateMatch = remaining.match(/(周|星期)([一二三四五六日天])/))) {
    const targetIso = WEEKDAY_MAP[dateMatch[2]];
    const targetJs = targetIso === 7 ? 0 : targetIso;
    const daysToAdd = ((targetJs - today.getDay() + 7) % 7) || 7;
    const d = new Date(today);
    d.setDate(d.getDate() + daysToAdd);
    resolvedDate = d;
    strip(dateMatch[0]);
  } else if ((dateMatch = remaining.match(/(\d+)[天日]后/))) {
    const d = new Date(today);
    d.setDate(d.getDate() + parseInt(dateMatch[1], 10));
    resolvedDate = d;
    strip(dateMatch[0]);
  } else if ((dateMatch = remaining.match(/(\d{1,2})月(\d{1,2})[日号]/))) {
    const d = new Date(today.getFullYear(), parseInt(dateMatch[1], 10) - 1, parseInt(dateMatch[2], 10));
    if (d < today) d.setFullYear(d.getFullYear() + 1);
    resolvedDate = d;
    strip(dateMatch[0]);
  }

  // --- 辅助：从文本中解析日期表达式 ---
  function parseDateToken(str) {
    const patterns = [
      { re: /大后天/, days: 3 },
      { re: /后天/, days: 2 },
      { re: /明天/, days: 1 },
      { re: /今天/, days: 0 },
    ];
    for (const { re, days } of patterns) {
      const m = str.match(re);
      if (m) {
        const d = new Date(today);
        d.setDate(d.getDate() + days);
        return { date: d, match: m[0], index: m.index };
      }
    }
    let m;
    if ((m = str.match(/下(周|星期)([一二三四五六日天])/))) {
      const targetIso = WEEKDAY_MAP[m[2]];
      const currentIso = today.getDay() || 7;
      const daysToNextMonday = (8 - currentIso) % 7 || 7;
      const d = new Date(today);
      d.setDate(d.getDate() + daysToNextMonday + (targetIso - 1));
      return { date: d, match: m[0], index: m.index };
    }
    if ((m = str.match(/(周|星期)([一二三四五六日天])/))) {
      const targetIso = WEEKDAY_MAP[m[2]];
      const targetJs = targetIso === 7 ? 0 : targetIso;
      const d = new Date(today);
      d.setDate(d.getDate() + ((targetJs - today.getDay() + 7) % 7 || 7));
      return { date: d, match: m[0], index: m.index };
    }
    if ((m = str.match(/(\d+)[天日]后/))) {
      const d = new Date(today);
      d.setDate(d.getDate() + parseInt(m[1], 10));
      return { date: d, match: m[0], index: m.index };
    }
    if ((m = str.match(/(\d{1,2})月(\d{1,2})[日号]/))) {
      const d = new Date(today.getFullYear(), parseInt(m[1], 10) - 1, parseInt(m[2], 10));
      if (d < today) d.setFullYear(d.getFullYear() + 1);
      return { date: d, match: m[0], index: m.index };
    }
    return null;
  }

  // --- 检测剩余文本中是否有第二个日期 ---
  let deadlineDate = null;
  const secondParsed = parseDateToken(remaining);
  if (secondParsed && resolvedDate) {
    const secondDate = secondParsed.date;
    if (secondDate >= resolvedDate) {
      deadlineDate = secondDate;
    } else {
      deadlineDate = resolvedDate;
      resolvedDate = secondDate;
    }
    strip(secondParsed.match);
  }

  let scope = "daily";
  if (deadlineDate) {
    scope = "deadline";
  } else if (/截止|到期/.test(remaining)) {
    scope = "deadline";
    strip(/截止|到期/);
  }

  let urgent = false;
  let important = false;
  if (/紧急/.test(remaining)) {
    urgent = true;
    strip("紧急");
  }
  if (/重要/.test(remaining)) {
    important = true;
    strip("重要");
  }

  // --- 智能推断紧急/重要（未来可替换为 AI API 调用） ---
  if (!urgent) {
    const urgencyPatterns = [/要交/, /必须[\s\S]*?完成/, /赶紧/, /马上/, /立刻/, /尽快/, /加急/, /来不及/, /ddl/i];
    if (urgencyPatterns.some((p) => p.test(text))) urgent = true;
  }
  if (!urgent) {
    const effectiveDate = deadlineDate || resolvedDate;
    if (effectiveDate) {
      const diffDays = Math.floor((effectiveDate - today) / (1000 * 60 * 60 * 24));
      if (diffDays <= 1) urgent = true;
    }
  }
  if (!important) {
    const importancePatterns = [/要交/, /考试/, /面试/, /汇报/, /答辩/, /客户/, /上线/, /发布/, /必须/];
    if (importancePatterns.some((p) => p.test(text))) important = true;
  }
  // 两个日期同时出现暗示事项有时间压力，标记为重要
  if (!important && deadlineDate && resolvedDate) {
    important = true;
  }

  // --- 提取 #标签 ---
  const tags = [];
  const tagRegex = /#([一-鿿_a-zA-Z0-9]+)/g;
  let tagMatch;
  while ((tagMatch = tagRegex.exec(remaining)) !== null) {
    tags.push(tagMatch[1]);
  }
  remaining = remaining.replace(/#[一-鿿_a-zA-Z0-9]+/g, "").trim();

  // --- 清理标题：去除日期短语、动词修饰、标点残留 ---
  remaining = remaining
    .replace(/[，,]?\s*(?:要|需要|得)?(?:写完|做完|完成|搞定|弄好|确定|提交|交)\s*/g, "")
    .replace(/[，,]?\s*(?:马上|尽快|赶紧)?要交\S*/g, "")
    .replace(/^\s*[，,]\s*/, "")
    .replace(/\s*[，,]\s*$/, "")
    .replace(/[，,]{2,}/g, "，")
    .trim();

  const title = remaining || text;
  if (!title) return null;

  const primaryDateStr = resolvedDate ? resolvedDate.toLocaleDateString("sv-SE") : getTodayDateString();
  const deadlineDateStr = deadlineDate ? deadlineDate.toLocaleDateString("sv-SE") : primaryDateStr;
  return {
    title,
    type: "其他",
    scope,
    urgent,
    important,
    taskDate: scope === "daily" ? primaryDateStr : "",
    dueDate: scope === "deadline" ? deadlineDateStr : "",
    tags,
  };
}

function cleanupDrag() {
  taskSections.querySelectorAll(".task-item.dragging").forEach((el) => el.classList.remove("dragging"));
  taskSections.querySelectorAll(".task-item.drag-over-top, .task-item.drag-over-bottom").forEach((el) => {
    el.classList.remove("drag-over-top", "drag-over-bottom");
  });
  state.drag.taskId = null;
  state.drag.sourceSectionKey = null;
  state.drag.targetSectionKey = null;
  state.drag.targetTaskId = null;
  state.drag.position = null;
}

function handleDragStart(event) {
  const handle = event.target.closest(".drag-handle");
  if (!handle) return;

  const item = handle.closest(".task-item");
  if (!item) return;

  const section = item.closest(".task-section");
  const sectionKey = section?.dataset.section;
  if (!sectionKey) return;

  state.drag.taskId = item.dataset.id;
  state.drag.sourceSectionKey = sectionKey;

  event.dataTransfer.effectAllowed = "move";
  event.dataTransfer.setData("text/plain", item.dataset.id);
  item.classList.add("dragging");
}

function handleDragOver(event) {
  if (!state.drag.taskId) return;

  const targetItem = event.target.closest(".task-item");
  if (!targetItem || targetItem.dataset.id === state.drag.taskId) return;

  const section = targetItem.closest(".task-section");
  if (!section) return;

  event.preventDefault();
  event.dataTransfer.dropEffect = "move";

  state.drag.targetSectionKey = section.dataset.section;
  state.drag.targetTaskId = targetItem.dataset.id;

  const rect = targetItem.getBoundingClientRect();
  state.drag.position = event.clientY < rect.top + rect.height / 2 ? "before" : "after";

  taskSections.querySelectorAll(".task-item.drag-over-top, .task-item.drag-over-bottom").forEach((el) => {
    el.classList.remove("drag-over-top", "drag-over-bottom");
  });
  targetItem.classList.add(state.drag.position === "before" ? "drag-over-top" : "drag-over-bottom");
}

function handleDrop(event) {
  event.preventDefault();

  const { taskId, sourceSectionKey, targetTaskId, targetSectionKey, position } = state.drag;
  if (!taskId || !targetTaskId || taskId === targetTaskId || sourceSectionKey !== targetSectionKey) {
    cleanupDrag();
    return;
  }

  const sectionKey = sourceSectionKey;
  const { todayTasks, deadlineTasks, archiveTasks } = getVisibleTaskGroups();
  const sectionTasks =
    sectionKey === "today" ? todayTasks : sectionKey === "deadline" ? deadlineTasks : archiveTasks;

  const fromIndex = sectionTasks.findIndex((t) => t.id === taskId);
  const toIndex = sectionTasks.findIndex((t) => t.id === targetTaskId);
  if (fromIndex === -1 || toIndex === -1) {
    cleanupDrag();
    return;
  }

  const reordered = [...sectionTasks];
  const [moved] = reordered.splice(fromIndex, 1);
  let insertAt = reordered.findIndex((t) => t.id === targetTaskId);
  if (position === "after") insertAt += 1;
  reordered.splice(insertAt, 0, moved);

  const newOrderMap = { ...state.taskOrder[sectionKey] };
  reordered.forEach((task, index) => {
    newOrderMap[task.id] = index;
  });

  state.taskOrder[sectionKey] = newOrderMap;
  saveToLocalStorage(ORDER_STORAGE_KEY, state.taskOrder);

  cleanupDrag();
  renderLists();
}

function handleDragEnd() {
  cleanupDrag();
}

function exportTasks() {
  const payload = {
    version: 1,
    exportedAt: new Date().toISOString(),
    tasks: state.tasks,
  };

  const blob = new Blob([JSON.stringify(payload, null, 2)], { type: "application/json" });
  const url = URL.createObjectURL(blob);
  const link = document.createElement("a");
  link.href = url;
  link.download = `todo-list-export-${getTodayDateString()}.json`;
  link.click();
  URL.revokeObjectURL(url);
}

function dedupeTasksById(tasks) {
  const seen = new Set();
  return tasks.filter((task) => {
    if (seen.has(task.id)) {
      return false;
    }

    seen.add(task.id);
    return true;
  });
}

function importTasks(event) {
  const [file] = event.target.files || [];
  if (!file) return;

  const reader = new FileReader();
  reader.addEventListener("load", () => {
    try {
      const parsed = JSON.parse(String(reader.result || "{}"));
      const nextTasks = Array.isArray(parsed) ? parsed : parsed.tasks;
      if (!Array.isArray(nextTasks)) {
        throw new Error("invalid");
      }

      const normalizedTasks = dedupeTasksById(nextTasks.map(normalizeTask).filter((task) => task.title.trim()));

      let finalTasks;
      if (state.tasks.length === 0) {
        // 本地无任务，直接导入
        finalTasks = normalizedTasks;
      } else {
        // 本地有任务，询问合并还是放弃
        const shouldMerge = window.confirm(
          "检测到已有任务。\n\n" +
          "点「确定」= 合并导入（同 id 保留较新的）\n" +
          "点「取消」= 放弃导入"
        );
        if (!shouldMerge) {
          importFileInput.value = "";
          return;
        }
        // 合并：按 id 去重，同 id 的比较 createdAt 保留较新的
        const existingMap = new Map(state.tasks.map((t) => [t.id, t]));
        for (const task of normalizedTasks) {
          const existing = existingMap.get(task.id);
          if (!existing || new Date(task.createdAt) > new Date(existing.createdAt)) {
            existingMap.set(task.id, task);
          }
        }
        finalTasks = Array.from(existingMap.values());
      }

      if (!commitTasks(finalTasks)) {
        return;
      }

      clearPendingDelete(false);
      clearUndoState();
      stopEditing();
      render();
    } catch {
      window.alert("导入失败，请选择有效的 JSON 文件。");
    } finally {
      importFileInput.value = "";
    }
  });

  reader.readAsText(file, "utf-8");
}

function toggleTask(taskId) {
  var currentTask = state.tasks.find(function (t) { return t.id === taskId; });
  if (!currentTask) return;
  var nextCompleted = !currentTask.completed;
  var nextTasks = state.tasks.map(function (t) {
    if (t.id === taskId) {
      var copy = {};
      for (var k in t) copy[k] = t[k];
      copy.completed = nextCompleted;
      return copy;
    }
    return t;
  });
  if (!commitTasks(nextTasks)) { render(); return; }
  clearPendingDelete(false);
  updateStats();

  // 完成时自动创建下一个重复实例
  if (nextCompleted && currentTask.recurrence && currentTask.recurrence.type) {
    var rec = currentTask.recurrence;
    var baseDate = currentTask.scope === 'daily' ? currentTask.taskDate : currentTask.dueDate;
    if (baseDate) {
      var d = new Date(baseDate + 'T00:00:00');
      if (rec.type === 'daily') d.setDate(d.getDate() + rec.interval);
      else if (rec.type === 'weekly') d.setDate(d.getDate() + 7 * rec.interval);
      else if (rec.type === 'monthly') d.setMonth(d.getMonth() + rec.interval);
      if (!rec.endDate || d.toISOString().slice(0, 10) <= rec.endDate) {
        var newSubtasks = currentTask.subtasks.map(function (s) {
          return { id: createTaskId(), title: s.title, completed: false };
        });
        var nextInstance = normalizeTask({
          id: createTaskId(),
          title: currentTask.title,
          type: currentTask.type,
          urgent: currentTask.urgent,
          important: currentTask.important,
          scope: currentTask.scope,
          taskDate: currentTask.scope === 'daily' ? d.toISOString().slice(0, 10) : '',
          dueDate: currentTask.scope === 'deadline' ? d.toISOString().slice(0, 10) : '',
          recurrence: currentTask.recurrence,
          subtasks: newSubtasks,
          createdAt: new Date().toISOString(),
          createdDate: getTodayDateString()
        });
        commitTasks([nextInstance].concat(state.tasks));
      }
    }
  }

  var nextItem = replaceTaskItem(taskId, nextCompleted);
  if (!nextItem) renderLists();
  var msg = nextCompleted ? '已完成' : '已恢复为进行中';
  showUndoToast(msg + ' “' + currentTask.title + '”', { type: 'toggle', taskId: taskId, previousCompleted: currentTask.completed });
}

function deleteTask(taskId) {
  const deleteIndex = state.tasks.findIndex((task) => task.id === taskId);
  if (deleteIndex === -1) return;

  const deletedTask = state.tasks[deleteIndex];
  // 软删除：标记为已删除，防止同步时被云端旧数据恢复
  const nextTasks = state.tasks.map((task) => {
    if (task.id !== taskId) return task;
    return { ...task, deleted: true, deletedAt: new Date().toISOString() };
  });
  if (!commitTasks(nextTasks)) return;
  // 删除后立即推送，避免延迟期间其他设备拉到旧数据
  pushToCloud();

  clearPendingDelete(false);
  if (state.editingTaskId === taskId) {
    stopEditing();
  }

  render();
  showUndoToast(`已删除“${deletedTask.title}”`, {
    type: "delete",
    task: deletedTask,
    index: deleteIndex,
  });
}

function toggleSection(sectionKey) {
  if (!(sectionKey in state.collapsedSections)) return;

  const nextValue = !state.collapsedSections[sectionKey];
  state.collapsedSections[sectionKey] = nextValue;

  if (!saveCollapsedSections()) {
    state.collapsedSections[sectionKey] = !nextValue;
    return;
  }

  syncSectionStates();
}

function handleSectionToggleClick(event) {
  const toggleButton = event.target.closest(".section-toggle");
  if (!toggleButton) return;

  toggleSection(toggleButton.closest(".task-section")?.dataset.section);
}

function handleTaskActionClick(event) {
  const item = event.target.closest(".task-item");
  if (!item) return;

  const taskId = item.dataset.id;
  if (event.target.matches(".edit-btn")) {
    startEditing(taskId);
    return;
  }

  if (event.target.matches(".delete-btn")) {
    if (state.pendingDelete.taskId === taskId) {
      deleteTask(taskId);
      return;
    }

    startPendingDelete(taskId);
  }
}

function handleTaskToggleChange(event) {
  if (!event.target.matches(".task-toggle")) return;

  const item = event.target.closest(".task-item");
  if (!item) return;

  clearPendingDelete(true);
  toggleTask(item.dataset.id);
}

function handleTaskItemKeyboard(event) {
  const item = event.target.closest(".task-item");
  if (!item || document.activeElement !== item) {
    return;
  }

  if (event.key === "ArrowDown") {
    event.preventDefault();
    focusAdjacentTaskItem(item, 1);
    return;
  }

  if (event.key === "ArrowUp") {
    event.preventDefault();
    focusAdjacentTaskItem(item, -1);
    return;
  }

  if (event.key === "Enter") {
    event.preventDefault();
    clearPendingDelete(true);
    toggleTask(item.dataset.id);
    return;
  }

  if (event.key === "Delete") {
    event.preventDefault();
    if (state.pendingDelete.taskId === item.dataset.id) {
      deleteTask(item.dataset.id);
      return;
    }

    startPendingDelete(item.dataset.id);
    return;
  }

  if (event.key === "e" || event.key === "E") {
    event.preventDefault();
    startEditing(item.dataset.id);
  }
}

// 子任务编辑交互
const subtaskInput = document.querySelector("#subtask-input");
const subtaskEditList = document.querySelector("#subtask-edit-list");

function renderSubtaskEditList() {
  if (!subtaskEditList) return;
  subtaskEditList.innerHTML = "";
  state.editingSubtasks.forEach((sub, index) => {
    const li = document.createElement("li");
    li.className = "subtask-edit-item";
    const span = document.createElement("span");
    span.textContent = sub.title;
    const removeBtn = document.createElement("button");
    removeBtn.type = "button";
    removeBtn.className = "subtask-edit-remove";
    removeBtn.textContent = "×";
    removeBtn.dataset.index = String(index);
    li.append(span, removeBtn);
    subtaskEditList.append(li);
  });
}

if (subtaskInput) {
  subtaskInput.addEventListener("keydown", (e) => {
    if (e.key === "Enter") {
      e.preventDefault();
      const title = subtaskInput.value.trim();
      if (!title) return;
      state.editingSubtasks.push({
        id: createTaskId(),
        title,
        completed: false,
      });
      subtaskInput.value = "";
      renderSubtaskEditList();
    }
  });
}

if (subtaskEditList) {
  subtaskEditList.addEventListener("click", (e) => {
    if (e.target.matches(".subtask-edit-remove")) {
      const index = parseInt(e.target.dataset.index, 10);
      state.editingSubtasks.splice(index, 1);
      renderSubtaskEditList();
    }
  });
}

form.addEventListener("submit", handleSubmit);
scopeInput.addEventListener("change", syncDateFields);
urgentInput.addEventListener("change", renderQuadrantPreview);
importantInput.addEventListener("change", renderQuadrantPreview);
exportButton.addEventListener("click", exportTasks);
importFileInput.addEventListener("change", importTasks);
cancelEditButton.addEventListener("click", stopEditing);
undoToastAction.addEventListener("click", handleUndo);
themeToggleButton?.addEventListener("click", handleThemeToggle);

// 手动添加折叠/展开
const composerToggle = document.querySelector(".composer-toggle");
const composerBody = document.querySelector(".composer-body");
if (composerToggle && composerBody) {
  composerToggle.addEventListener("click", () => {
    const expanded = composerToggle.getAttribute("aria-expanded") === "true";
    composerToggle.setAttribute("aria-expanded", String(!expanded));
    composerBody.hidden = expanded;
  });
}
searchFilter.addEventListener("input", (event) => {
  const nextValue = event.target.value;

  if (state.searchDebounceId) {
    clearTimeout(state.searchDebounceId);
  }

  state.searchDebounceId = window.setTimeout(() => {
    state.filters.search = nextValue;
    renderLists();
  }, 200);
});
statusFilter.addEventListener("change", (event) => {
  state.filters.status = event.target.value;
  renderLists();
});
typeFilter.addEventListener("change", (event) => {
  state.filters.type = event.target.value;
  renderLists();
});
quadrantFilter.addEventListener("change", (event) => {
  state.filters.quadrant = event.target.value;
  renderLists();
});
const tagFilter = document.querySelector("#filter-tag");
tagFilter?.addEventListener("change", (event) => {
  state.filters.tag = event.target.value;
  renderLists();
});
sortModeInput?.addEventListener("change", (event) => {
  const nextSortMode = event.target.value;
  if (!saveSortMode(nextSortMode)) {
    sortModeInput.value = state.sortMode;
    return;
  }

  state.sortMode = nextSortMode;
  renderLists();
});
overdueStatCard?.addEventListener("click", () => {
  setOverdueFilter(!state.filters.overdueOnly);
});
loginToggle?.addEventListener("click", () => {
  if (state.login.isLoggedIn) {
    handleLogout();
    return;
  }
  openLoginModal();
});
loginCancelBtn?.addEventListener("click", closeLoginModal);
sendCodeBtn?.addEventListener("click", sendVerificationCode);
loginSubmitBtn?.addEventListener("click", handleLogin);
loginModal?.querySelector(".login-modal-backdrop")?.addEventListener("click", closeLoginModal);

quickAddForm.addEventListener("submit", (event) => {
  event.preventDefault();
  const rawText = quickAddInput.value.trim();
  if (!rawText) return;

  const parsed = parseQuickAdd(rawText);
  if (!parsed) return;

  const newTask = normalizeTask({
    id: createTaskId(),
    title: parsed.title,
    type: parsed.type,
    scope: parsed.scope,
    urgent: parsed.urgent,
    important: parsed.important,
    taskDate: parsed.taskDate,
    dueDate: parsed.dueDate,
    tags: parsed.tags || [],
    createdAt: new Date().toISOString(),
    createdDate: getTodayDateString(),
  });

  if (!commitTasks([newTask, ...state.tasks])) return;

  // 确保新任务所在的分区是展开的
  var qSectionKey = getTaskSectionKey(newTask);
  if (state.collapsedSections[qSectionKey]) {
    state.collapsedSections[qSectionKey] = false;
    saveCollapsedSections();
  }

  clearPendingDelete(false);
  render();
  scrollToTask(newTask.id);
  quickAddInput.value = "";
});

taskSections.addEventListener("click", handleSectionToggleClick);
taskSections.addEventListener("click", handleTaskActionClick);
taskSections.addEventListener("change", handleTaskToggleChange);
taskSections.addEventListener("change", (event) => {
  if (!event.target.matches(".subtask-toggle")) return;
  const item = event.target.closest(".task-item");
  if (!item) return;
  const taskId = item.dataset.id;
  const subtaskId = event.target.dataset.subtaskId;

  const nextTasks = state.tasks.map((task) => {
    if (task.id !== taskId) return task;
    return {
      ...task,
      subtasks: task.subtasks.map((sub) =>
        sub.id === subtaskId ? { ...sub, completed: !sub.completed } : sub
      ),
    };
  });

  if (!commitTasks(nextTasks)) return;
  updateStats();
  replaceTaskItem(taskId, false);
});
taskSections.addEventListener("keydown", handleTaskItemKeyboard);
taskSections.addEventListener("dragstart", handleDragStart);
taskSections.addEventListener("dragover", handleDragOver);
taskSections.addEventListener("drop", handleDrop);
taskSections.addEventListener("dragend", handleDragEnd);
taskSections.addEventListener("dragleave", (event) => {
  if (!taskSections.contains(event.relatedTarget)) {
    taskSections.querySelectorAll(".task-item.drag-over-top, .task-item.drag-over-bottom").forEach((el) => {
      el.classList.remove("drag-over-top", "drag-over-bottom");
    });
  }
});
document.addEventListener("keydown", (event) => {
  // Escape 关闭弹窗/取消编辑
  if (event.key === "Escape") {
    event.preventDefault();
    if (!loginModal?.hidden) {
      closeLoginModal();
      return;
    }
    if (state.editingTaskId) {
      stopEditing();
    }
    return;
  }

  // 忽略在输入框内的按键
  const tag = event.target.tagName;
  const isInput = tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT";
  if (isInput) return;

  // N — 聚焦快速添加
  if (event.key === "n" || event.key === "N") {
    event.preventDefault();
    quickAddInput?.focus();
    return;
  }

  // / — 聚焦搜索框
  if (event.key === "/") {
    event.preventDefault();
    searchFilter?.focus();
    return;
  }
});

const themeMediaQuery = window.matchMedia(THEME_MEDIA_QUERY);
applyTheme(getResolvedTheme());
sortModeInput.value = state.sortMode;
if (typeof themeMediaQuery.addEventListener === "function") {
  themeMediaQuery.addEventListener("change", syncThemeWithSystem);
} else if (typeof themeMediaQuery.addListener === "function") {
  themeMediaQuery.addListener(syncThemeWithSystem);
}

resetForm();
render();
checkLoginState();

// 提醒权限请求
const reminderSel = document.querySelector("#task-reminder");
if (reminderSel) {
  reminderSel.addEventListener("change", () => {
    if (reminderSel.value && "Notification" in window && Notification.permission === "default") {
      Notification.requestPermission();
    }
  });
}

// 每分钟检查提醒
setInterval(() => {
  if (!("Notification" in window) || Notification.permission !== "granted") return;
  const now = new Date();
  const nowStr = now.toISOString().slice(0, 16);
  state.tasks.forEach((task) => {
    if (!task.reminderAt || task.completed) return;
    if (!task.reminderAt.startsWith(nowStr)) return;
    new Notification("待办提醒", {
      body: task.title,
      icon: "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>📋</text></svg>",
    });
    // 触发后清除提醒，避免重复通知
    const nextTasks = state.tasks.map((t) =>
      t.id === task.id ? { ...t, reminderAt: "" } : t
    );
    commitTasks(nextTasks);
  });
}, 60000);