data.js｜白板資料層完整程式

import { BOARD_SLUG, isDemoMode } from './config.js';
import { sortPosts } from './sorting.js';
import { supabase } from './supabase.js';
import { nowIso } from './utils.js';

const DEMO_STORAGE_KEY = 'live-board-mvp-demo-state-v2';
const DEMO_CHANNEL_NAME = 'live-board-mvp-demo-sync';

const ATTACHMENT_BUCKET = 'live-board-attachments';
export const MAX_ATTACHMENT_SIZE = 10 * 1024 * 1024;
export const ALLOWED_ATTACHMENT_TYPES = new Set([
  'application/pdf',
  'application/msword',
  'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
  'application/vnd.ms-powerpoint',
  'application/vnd.openxmlformats-officedocument.presentationml.presentation',
  'application/vnd.ms-excel',
  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
  'image/png',
  'image/jpeg',
  'image/gif',
  'image/webp',
  'application/zip',
  'text/plain',
  'text/csv',
]);

const boardFields = 'id, slug, title, is_active, is_archived, archived_at, archived_by, purge_after, sort_mode, created_by, created_at, updated_at';
const publicBoardFields = 'id, slug, title, is_active, is_archived, sort_mode, created_at, updated_at';
const postFields = 'id, board_id, title, body, sort_order, published, published_at, publish_at, unpublish_at, pinned, locked, locked_at, locked_by, default_collapsed, created_at, updated_at';
const publicPostFields = 'id, board_id, title, body, sort_order, published, published_at, publish_at, unpublish_at, pinned, locked, default_collapsed, created_at, updated_at';
const publicPostSummaryFields = 'id, board_id, title, sort_order, published, published_at, publish_at, unpublish_at, pinned, locked, default_collapsed, created_at, updated_at';
const attachmentFields = 'id, board_id, post_id, storage_path, file_name, mime_type, file_size, created_by, created_at';

const seedDemoState = {
  boards: [
    {
      id: 'demo-board',
      slug: BOARD_SLUG,
      title: '課堂即時公佈欄',
      is_active: true,
      is_archived: false,
      purge_after: null,
      sort_mode: 'newest',
      created_by: 'demo-user',
      created_at: '2026-08-20T00:00:00.000Z',
      updated_at: '2026-08-20T00:00:00.000Z',
    },
  ],
  posts: [
    {
      id: 'demo-post-1',
      board_id: 'demo-board',
      title: '上課指令範例',
      body: '請先開啟你慣用的 AI 工具，準備好之後回到這個白板。\n\n接著複製下一則公告中的指令。',
      sort_order: 10,
      published: true,
      published_at: '2026-08-20T00:00:00.000Z',
      publish_at: '2026-08-20T00:00:00.000Z',
      unpublish_at: null,
      pinned: false,
      locked: false,
      default_collapsed: true,
      created_at: '2026-08-20T00:00:00.000Z',
      updated_at: '2026-08-20T00:00:00.000Z',
    },
    {
      id: 'demo-post-2',
      board_id: 'demo-board',
      title: '長文字也可以保留換行',
      body: '這裡是示範內容。教師可以貼上多行指令、網址與課程提醒，學員端可以收摺，也可以直接複製完整內容。',
      sort_order: 20,
      published: true,
      published_at: '2026-08-20T00:01:00.000Z',
      publish_at: '2026-08-20T00:01:00.000Z',
      unpublish_at: null,
      pinned: true,
      locked: false,
      default_collapsed: true,
      created_at: '2026-08-20T00:01:00.000Z',
      updated_at: '2026-08-20T00:01:00.000Z',
    },
  ],
};

let demoBroadcastChannel;

function clone(value) {
  return JSON.parse(JSON.stringify(value));
}

function normalizeDemoState(saved) {
  if (saved?.boards && Array.isArray(saved.posts)) {
    return {
      boards: saved.boards.map((board) => ({ sort_mode: 'newest', is_archived: false, purge_after: null, ...board })),
      posts: saved.posts.map((post) => ({
        published_at: post.published ? post.updated_at || post.created_at : null,
        publish_at: post.published ? post.updated_at || post.created_at : null,
        unpublish_at: null,
        attachments: [],
        pinned: false,
        locked: false,
        ...post,
      })),
    };
  }

  if (saved?.board && Array.isArray(saved.posts)) {
    return {
      boards: [{ sort_mode: 'newest', is_archived: false, purge_after: null, ...saved.board }],
      posts: saved.posts.map((post) => ({
        published_at: post.published ? post.updated_at || post.created_at : null,
        publish_at: post.published ? post.updated_at || post.created_at : null,
        unpublish_at: null,
        attachments: [],
        pinned: false,
        locked: false,
        ...post,
      })),
    };
  }

  return clone(seedDemoState);
}

function readDemoState() {
  try {
    const saved = localStorage.getItem(DEMO_STORAGE_KEY);
    if (saved) return normalizeDemoState(JSON.parse(saved));
  } catch {
    // Continue with the seed data if local storage is unavailable.
  }
  return clone(seedDemoState);
}

function writeDemoState(state, boardId) {
  try {
    localStorage.setItem(DEMO_STORAGE_KEY, JSON.stringify(state));
  } catch {
    // The current tab can still use the in-memory state.
  }
  if (typeof BroadcastChannel !== 'undefined') {
    demoBroadcastChannel ||= new BroadcastChannel(DEMO_CHANNEL_NAME);
    demoBroadcastChannel.postMessage({ boardId, at: nowIso() });
  }
  window.dispatchEvent(new CustomEvent('live-board-demo-change', { detail: boardId }));
}

function getDemoBoard(state, slug, includeInactive = false) {
  return state.boards.find((board) => board.slug === slug && (includeInactive || board.is_active));
}

function toIsoOrNull(value) {
  if (!value) return null;
  const date = new Date(value);
  if (Number.isNaN(date.getTime())) throw new Error('排程時間格式不正確。');
  return date.toISOString();
}

function isPostVisible(post, now = Date.now()) {
  if (!post.published) return false;
  const publishAt = post.publish_at || post.published_at;
  const unpublishAt = post.unpublish_at ? new Date(post.unpublish_at).getTime() : null;
  const publishTime = publishAt ? new Date(publishAt).getTime() : 0;
  return (!publishAt || (!Number.isNaN(publishTime) && publishTime <= now))
    && (unpublishAt == null || (!Number.isNaN(unpublishAt) && unpublishAt > now));
}

function getNextScheduleAt(posts, now = Date.now()) {
  const times = posts
    .flatMap((post) => [post.publish_at, post.unpublish_at])
    .filter(Boolean)
    .map((value) => new Date(value).getTime())
    .filter((value) => !Number.isNaN(value) && value > now)
    .sort((a, b) => a - b);
  return times[0] || null;
}

function getPostPayload(values) {
  const published = values.published !== false;
  const publishAt = published ? (toIsoOrNull(values.publish_at) || nowIso()) : null;
  const unpublishAt = published ? toIsoOrNull(values.unpublish_at) : null;
  if (publishAt && unpublishAt && new Date(unpublishAt) <= new Date(publishAt)) {
    throw new Error('自動下架時間必須晚於發布時間。');
  }

  return {
    board_id: values.board_id,
    title: String(values.title || '').trim(),
    body: String(values.body || ''),
    sort_order: Number(values.sort_order) || 10,
    published,
    publish_at: publishAt,
    unpublish_at: unpublishAt,
    default_collapsed: Boolean(values.default_collapsed),
    pinned: Boolean(values.pinned),
    locked: Boolean(values.locked),
  };
}

async function loadDemoBoard(slug = BOARD_SLUG, includeInactive = false) {
  const state = readDemoState();
  const board = getDemoBoard(state, slug, includeInactive);
  if (!board) return { board: null, posts: [], nextRefreshAt: null };
  const boardPosts = state.posts.filter((post) => post.board_id === board.id);
  const posts = boardPosts.filter((post) => includeInactive || isPostVisible(post));
  return {
    board: clone(board),
    posts: sortPosts(clone(posts), board.sort_mode),
    nextRefreshAt: includeInactive ? null : getNextScheduleAt(boardPosts),
  };
}

export async function listBoards({ includeInactive = true } = {}) {
  if (isDemoMode) {
    const state = readDemoState();
    return state.boards
      .filter((board) => includeInactive || board.is_active)
      .sort((a, b) => a.title.localeCompare(b.title, 'zh-Hant'))
      .map(clone);
  }

  let query = supabase.from('boards').select(boardFields).order('title', { ascending: true });
  if (!includeInactive) query = query.eq('is_active', true);
  const { data, error } = await query;
  if (error) throw error;
  return data || [];
}

export async function loadBoard(slug = BOARD_SLUG, { includeInactive = false } = {}) {
  if (isDemoMode) return loadDemoBoard(slug, includeInactive);

  let boardQuery = supabase
    .from('boards')
    .select(includeInactive ? boardFields : publicBoardFields)
    .eq('slug', slug);
  if (!includeInactive) boardQuery = boardQuery.eq('is_active', true);
  const { data: board, error: boardError } = await boardQuery.maybeSingle();
  if (boardError) throw boardError;
  if (!board) return { board: null, posts: [] };

  let postsQuery = supabase
    .from('board_posts')
    .select(includeInactive ? postFields : publicPostSummaryFields)
    .eq('board_id', board.id);
  if (!includeInactive) postsQuery = postsQuery.eq('published', true);
  const { data: posts, error: postsError } = await postsQuery;
  if (postsError) throw postsError;
  const attachmentMap = new Map();
  if (includeInactive) {
    const { data: attachments, error: attachmentError } = await supabase
      .from('board_post_attachments')
      .select(attachmentFields)
      .eq('board_id', board.id)
      .order('created_at', { ascending: true });
    if (attachmentError) throw attachmentError;
    (attachments || []).forEach((attachment) => {
      const { data: publicUrlData } = supabase.storage.from(ATTACHMENT_BUCKET).getPublicUrl(attachment.storage_path);
      const enriched = { ...attachment, public_url: publicUrlData.publicUrl };
      const list = attachmentMap.get(attachment.post_id) || [];
      list.push(enriched);
      attachmentMap.set(attachment.post_id, list);
    });
  }
  const enrichedPosts = includeInactive
    ? (posts || []).map((post) => ({ ...post, attachments: attachmentMap.get(post.id) || [] }))
    : (posts || []).filter((post) => isPostVisible(post)).map((post) => ({ ...post }));
  return {
    board,
    posts: sortPosts(enrichedPosts, board.sort_mode),
    nextRefreshAt: includeInactive ? null : getNextScheduleAt(posts || []),
  };
}

export async function loadPostAttachments(postId) {
  if (isDemoMode) {
    const state = readDemoState();
    const post = state.posts.find((item) => item.id === postId);
    return clone(post?.attachments || []);
  }

  const { data, error } = await supabase
    .from('board_post_attachments')
    .select(attachmentFields)
    .eq('post_id', postId)
    .order('created_at', { ascending: true });
  if (error) throw error;
  return (data || []).map((attachment) => {
    const { data: publicUrlData } = supabase.storage.from(ATTACHMENT_BUCKET).getPublicUrl(attachment.storage_path);
    return { ...attachment, public_url: publicUrlData.publicUrl };
  });
}

export async function loadPostContent(postId) {
  if (isDemoMode) {
    const state = readDemoState();
    const post = state.posts.find((item) => item.id === postId);
    return post && isPostVisible(post) ? clone(post) : null;
  }

  const { data, error } = await supabase
    .from('board_posts')
    .select(publicPostFields)
    .eq('id', postId)
    .eq('published', true)
    .maybeSingle();
  if (error) throw error;
  return data && isPostVisible(data) ? data : null;
}

export async function createBoard(values, userId) {
  const payload = {
    slug: String(values.slug || '').trim(),
    title: String(values.title || '').trim() || '課堂即時公佈欄',
    sort_mode: values.sort_mode || 'newest',
    is_active: values.is_active !== false,
    purge_after: toIsoOrNull(values.purge_after),
    created_by: userId,
  };

  if (isDemoMode) {
    const state = readDemoState();
    if (state.boards.some((board) => board.slug === payload.slug)) throw new Error('白板代碼已存在，請換一個代碼。');
    const timestamp = nowIso();
    const board = { ...payload, is_archived: false, purge_after: null, id: `demo-board-${crypto.randomUUID()}`, created_at: timestamp, updated_at: timestamp };
    state.boards.push(board);
    writeDemoState(state, board.id);
    return clone(board);
  }

  const { data, error } = await supabase.from('boards').insert(payload).select(boardFields).single();
  if (error) throw error;
  return data;
}

export async function ensureBoard(slug, title, userId) {
  const existing = await loadBoard(slug, { includeInactive: true });
  if (existing.board) return existing.board;
  return createBoard({ slug, title, sort_mode: 'newest', is_active: true }, userId);
}

export async function updateBoard(boardId, values) {
  if (isDemoMode) {
    const state = readDemoState();
    const index = state.boards.findIndex((item) => item.id === boardId);
    if (index < 0) throw new Error('找不到要更新的白板。');
    state.boards[index] = { ...state.boards[index], ...values, updated_at: nowIso() };
    writeDemoState(state, boardId);
    return clone(state.boards[index]);
  }

  const { data, error } = await supabase.from('boards').update(values).eq('id', boardId).select(boardFields).single();
  if (error) throw error;
  return data;
}

export async function savePost(values) {
  const payload = getPostPayload(values);

  if (isDemoMode) {
    const state = readDemoState();
    const timestamp = nowIso();
    if (values.id) {
      const index = state.posts.findIndex((post) => post.id === values.id);
      if (index < 0) throw new Error('找不到要更新的公告。');
      if (state.posts[index].locked && payload.body !== state.posts[index].body) {
        throw new Error('這則公告的本文已鎖定，請先解除鎖定後再修改。');
      }
      const previous = state.posts[index];
      state.posts[index] = {
        ...previous,
        ...payload,
        published_at: payload.published && payload.publish_at <= timestamp ? previous.published_at || payload.publish_at : null,
        locked_at: payload.locked ? previous.locked_at || timestamp : null,
        updated_at: timestamp,
      };
      writeDemoState(state, payload.board_id);
      return clone(state.posts[index]);
    }

    const post = {
      ...payload,
      id: `demo-post-${crypto.randomUUID()}`,
      published_at: payload.published && payload.publish_at <= timestamp ? payload.publish_at : null,
      publish_at: payload.publish_at,
      unpublish_at: payload.unpublish_at,
      locked_at: payload.locked ? timestamp : null,
      created_at: timestamp,
      updated_at: timestamp,
    };
    state.posts.push(post);
    writeDemoState(state, payload.board_id);
    return clone(post);
  }

  const query = values.id
    ? supabase.from('board_posts').update(payload).eq('id', values.id)
    : supabase.from('board_posts').insert(payload);
  const { data, error } = await query.select(postFields).single();
  if (error) throw error;
  return data;
}

export async function deletePost(postId) {
  if (isDemoMode) {
    const state = readDemoState();
    const post = state.posts.find((item) => item.id === postId);
    state.posts = state.posts.filter((item) => item.id !== postId);
    writeDemoState(state, post?.board_id);
    return;
  }

  const { data: attachments, error: attachmentError } = await supabase
    .from('board_post_attachments')
    .select('id, storage_path')
    .eq('post_id', postId);
  if (attachmentError) throw attachmentError;
  if (attachments?.length) {
    const { error: storageError } = await supabase.storage
      .from(ATTACHMENT_BUCKET)
      .remove(attachments.map((item) => item.storage_path));
    if (storageError) throw storageError;
  }

  const { error: metadataError } = await supabase.from('board_post_attachments').delete().eq('post_id', postId);
  if (metadataError) throw metadataError;
  const { error } = await supabase.from('board_posts').delete().eq('id', postId);
  if (error) throw error;
}

export async function uploadAttachment({ boardId, postId, file, userId }) {
  if (isDemoMode) {
    const attachment = {
      id: `demo-attachment-${crypto.randomUUID()}`,
      board_id: boardId,
      post_id: postId,
      file_name: file.name,
      mime_type: file.type || 'application/octet-stream',
      file_size: file.size,
      storage_path: `${boardId}/${postId}/${file.name}`,
      public_url: URL.createObjectURL(file),
      created_at: nowIso(),
    };
    const state = readDemoState();
    const post = state.posts.find((item) => item.id === postId);
    if (post) {
      post.attachments ||= [];
      post.attachments.push(attachment);
      writeDemoState(state, boardId);
    }
    return attachment;
  }

  if (file.size > MAX_ATTACHMENT_SIZE) throw new Error('單一附件不可超過 10 MB。');
  if (!ALLOWED_ATTACHMENT_TYPES.has(file.type)) throw new Error(`不支援的附件格式：${file.type || '未知格式'}。`);

  const safeName = file.name.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(-120) || 'attachment';
  const storagePath = `${boardId}/${postId}/${crypto.randomUUID()}-${safeName}`;
  const { error: uploadError } = await supabase.storage
    .from(ATTACHMENT_BUCKET)
    .upload(storagePath, file, { cacheControl: '3600', contentType: file.type, upsert: false });
  if (uploadError) throw uploadError;

  const { data: publicUrlData } = supabase.storage.from(ATTACHMENT_BUCKET).getPublicUrl(storagePath);
  const { data, error } = await supabase
    .from('board_post_attachments')
    .insert({
      board_id: boardId,
      post_id: postId,
      storage_path: storagePath,
      file_name: file.name,
      mime_type: file.type,
      file_size: file.size,
      created_by: userId,
    })
    .select(attachmentFields)
    .single();
  if (error) {
    await supabase.storage.from(ATTACHMENT_BUCKET).remove([storagePath]);
    throw error;
  }
  return { ...data, public_url: publicUrlData.publicUrl };
}

export async function deleteAttachment(attachment) {
  if (isDemoMode) {
    const state = readDemoState();
    const post = state.posts.find((item) => item.id === attachment.post_id);
    if (post) post.attachments = (post.attachments || []).filter((item) => item.id !== attachment.id);
    writeDemoState(state, attachment.board_id);
    return;
  }
  const { error: storageError } = await supabase.storage.from(ATTACHMENT_BUCKET).remove([attachment.storage_path]);
  if (storageError) throw storageError;
  const { error } = await supabase.from('board_post_attachments').delete().eq('id', attachment.id);
  if (error) throw error;
}

export async function setBoardArchived(boardId, archived, { purgeAfter = null } = {}) {
  const values = {
    is_archived: Boolean(archived),
    purge_after: archived ? toIsoOrNull(purgeAfter) : null,
  };
  return updateBoard(boardId, values);
}

export async function reorderPosts(posts) {
  if (isDemoMode) {
    const state = readDemoState();
    const order = new Map(posts.map((post, index) => [post.id, (index + 1) * 10]));
    state.posts = state.posts.map((post) => ({
      ...post,
      sort_order: order.get(post.id) ?? post.sort_order,
      updated_at: nowIso(),
    }));
    writeDemoState(state, posts[0]?.board_id);
    return;
  }

  const updates = posts.map((post, index) =>
    supabase.from('board_posts').update({ sort_order: (index + 1) * 10 }).eq('id', post.id),
  );
  const results = await Promise.all(updates);
  const failed = results.find((result) => result.error);
  if (failed?.error) throw failed.error;
}

export async function loadAuditLogs(postId) {
  if (isDemoMode) return [];
  const { data, error } = await supabase
    .from('board_post_audit_logs')
    .select('id, action, actor_id, changed_fields, created_at')
    .eq('post_id', postId)
    .order('created_at', { ascending: false });
  if (error) throw error;
  return data || [];
}

export function subscribeToBoard(boardId, onChange, onStatus) {
  if (isDemoMode) {
    const handleChange = (event) => {
      if (event.detail === boardId) onChange({ board_id: boardId });
    };
    const handleStorage = (event) => {
      if (event.key === DEMO_STORAGE_KEY) onChange({ board_id: boardId });
    };
    let channel;
    if (typeof BroadcastChannel !== 'undefined') {
      channel = new BroadcastChannel(DEMO_CHANNEL_NAME);
      channel.onmessage = (event) => {
        if (event.data?.boardId === boardId) onChange({ board_id: boardId });
      };
    }
    window.addEventListener('live-board-demo-change', handleChange);
    window.addEventListener('storage', handleStorage);
    onStatus?.({ connected: true, label: '本機示範同步', kind: 'demo' });
    return () => {
      channel?.close();
      window.removeEventListener('live-board-demo-change', handleChange);
      window.removeEventListener('storage', handleStorage);
    };
  }

  const channel = supabase
    .channel(`board:${boardId}`, { config: { broadcast: { self: false } } })
    .on('broadcast', { event: 'board_changed' }, (payload) => {
      if (!payload.payload?.board_id || payload.payload.board_id === boardId) onChange(payload.payload || { board_id: boardId });
    })
    .subscribe((status) => {
      if (status === 'SUBSCRIBED') onStatus?.({ connected: true, label: '即時同步中', kind: 'live' });
      else if (status === 'CHANNEL_ERROR' || status === 'TIMED_OUT' || status === 'CLOSED') {
        onStatus?.({ connected: false, label: '即時連線中斷，使用 HTTPS 備援', kind: 'fallback' });
      }
    });

  return () => supabase.removeChannel(channel);
}