background.js

importScripts("storage.js", "i18n.js");

const MENU_ID = "clipnote-save-selection";
const NOTION_VERSION = "2025-09-03";
const MAX_NOTION_TEXT_LENGTH = 2000;
const MAX_NOTION_RETRY_COUNT = 2;
const MAX_NOTION_CHILDREN_PER_REQUEST = 100;

const syncingNoteIds = new Set();
let isSyncingAllNotes = false;

function t(key, params) {
  return ClipNoteI18n.t(key, params);
}

async function createContextMenu() {
  await ClipNoteI18n.init().catch((error) => {
    console.warn("ClipNote i18n init failed:", error?.message || error);
  });

  return new Promise((resolve) => {
    chrome.contextMenus.removeAll(() => {
      chrome.contextMenus.create({
        id: MENU_ID,
        title: t("background.contextMenuSave"),
        contexts: ["selection"]
      }, () => {
        if (chrome.runtime.lastError) {
          console.warn("ClipNote menu setup failed:", chrome.runtime.lastError.message);
        }
        resolve();
      });
    });
  });
}

function openTagDialog() {
  return new Promise((resolve) => {
    chrome.windows.create({
      url: chrome.runtime.getURL("tag-dialog.html"),
      type: "popup",
      width: 460,
      height: 620,
      focused: true
    }, () => {
      if (chrome.runtime.lastError) {
        console.warn("ClipNote tag dialog failed:", chrome.runtime.lastError.message);
      }
      resolve();
    });
  });
}

async function saveDraftAndOpenTagDialog({ text, url, title }) {
  const cleanText = String(text || "").trim();
  if (!cleanText) {
    return;
  }

  await ClipNoteStore.saveDraft({
    text: cleanText,
    url: url || "",
    title: title || t("background.untitledPage")
  });
  await openTagDialog();
}

function getActiveTab() {
  return new Promise((resolve, reject) => {
    chrome.tabs.query({ active: true, currentWindow: true }, ([tab]) => {
      if (chrome.runtime.lastError) {
        reject(new Error(chrome.runtime.lastError.message));
        return;
      }
      if (!tab?.id) {
        reject(new Error(t("background.noActiveTab")));
        return;
      }
      resolve(tab);
    });
  });
}

async function getSelectedTextFromTab(tabId) {
  const [result] = await chrome.scripting.executeScript({
    target: { tabId },
    func: () => String(globalThis.getSelection?.() || "").trim()
  });
  return String(result?.result || "").trim();
}

async function saveActiveTabSelection() {
  const tab = await getActiveTab();
  if (!ClipNoteStore.isSupportedUrl(tab.url)) {
    return;
  }

  const text = await getSelectedTextFromTab(tab.id);
  await saveDraftAndOpenTagDialog({
    text,
    url: tab.url,
    title: tab.title
  });
}

function sendMessageResponse(sendResponse, promise) {
  promise
    .then((result) => sendResponse({ ok: true, result }))
    .catch((error) => sendResponse({
      ok: false,
      error: error?.message || t("background.operationFailed")
    }));
  return true;
}

function assertNotionSettings(settings) {
  if (!settings.token) {
    throw new Error(t("background.notionTokenRequired"));
  }

  if (/[^\x20-\x7E]/.test(settings.token)) {
    throw new Error(t("background.invalidToken"));
  }

  if (settings.targetType === "data_source" && !settings.dataSourceId) {
    throw new Error(t("background.dataSourceRequired"));
  }

  if (settings.targetType === "database" && !settings.databaseId) {
    throw new Error(t("background.databaseRequired"));
  }

  if (settings.targetType === "page" && !settings.parentPageId) {
    throw new Error(t("background.parentPageRequired"));
  }
}

function truncateForNotionText(value) {
  return String(value || "").slice(0, MAX_NOTION_TEXT_LENGTH);
}

function wait(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
}

async function fetchNotionWithRetry(url, options, attempt = 0) {
  const response = await fetch(url, options);
  if (![429, 503, 504].includes(response.status) || attempt >= MAX_NOTION_RETRY_COUNT) {
    return response;
  }

  const retryAfterSeconds = Number(response.headers.get("Retry-After") || "0");
  const delayMs = retryAfterSeconds > 0
    ? retryAfterSeconds * 1000
    : (2 ** attempt) * 1000;
  await wait(delayMs);
  return fetchNotionWithRetry(url, options, attempt + 1);
}

function buildNotionParent(settings) {
  if (settings.targetType === "data_source") {
    return {
      type: "data_source_id",
      data_source_id: settings.dataSourceId
    };
  }

  if (settings.targetType === "database") {
    return {
      type: "data_source_id",
      data_source_id: settings.resolvedDataSourceId
    };
  }

  return {
    type: "page_id",
    page_id: settings.parentPageId
  };
}

function buildNotionProperties(note, settings) {
  if (["database", "data_source"].includes(settings.targetType)) {
    return ClipNoteStore.buildNotionDataSourceProperties(note);
  }

  return {
    title: {
      title: [
        {
          text: {
            content: truncateForNotionText(ClipNoteStore.buildNotionPageTitle(note))
          }
        }
      ]
    }
  };
}

async function requestNotion(path, settings, options = {}) {
  const response = await fetchNotionWithRetry(`https://api.notion.com${path}`, {
    ...options,
    headers: {
      "Authorization": `Bearer ${settings.token}`,
      "Content-Type": "application/json",
      "Notion-Version": NOTION_VERSION,
      ...(options.headers || {})
    }
  });

  const data = await response.json().catch(() => ({}));
  if (!response.ok) {
    const code = data.code ? `${data.code}: ` : "";
    throw new Error(t("background.notionApiFailed", {
      code,
      message: data.message || t("background.notionApiStatusFailed", { status: response.status })
    }));
  }
  return data;
}

function chunkArray(items, size) {
  const chunks = [];
  for (let index = 0; index < items.length; index += size) {
    chunks.push(items.slice(index, index + size));
  }
  return chunks;
}

async function resolveNotionSettings(settings) {
  if (settings.targetType !== "database") {
    return settings;
  }

  const database = await requestNotion(`/v1/databases/${settings.databaseId}`, settings);
  const dataSource = database.data_sources?.[0];
  const dataSourceId = dataSource?.id || dataSource?.data_source_id;
  if (!dataSourceId) {
    throw new Error(t("background.databaseDataSourceMissing"));
  }

  return {
    ...settings,
    resolvedDataSourceId: dataSourceId.replace(/-/g, ""),
    resolvedDataSourceName: dataSource.name || dataSource.title?.[0]?.plain_text || t("background.unnamedDataSource")
  };
}

async function getResolvedDataSource(settings) {
  const resolvedSettings = await resolveNotionSettings(settings);
  const dataSourceId = resolvedSettings.targetType === "data_source"
    ? resolvedSettings.dataSourceId
    : resolvedSettings.resolvedDataSourceId;
  return {
    resolvedSettings,
    dataSource: await requestNotion(`/v1/data_sources/${dataSourceId}`, resolvedSettings)
  };
}

function assertPropertyType(properties, name, type) {
  const property = properties?.[name];
  if (!property) {
    throw new Error(t("background.propertyMissing", { name }));
  }
  if (property.type !== type) {
    throw new Error(t("background.propertyWrongType", { name, type, actual: property.type }));
  }
}

async function testNotionConnection() {
  const settings = await ClipNoteStore.getNotionSettings();
  assertNotionSettings(settings);

  if (settings.targetType === "page") {
    await requestNotion(`/v1/pages/${settings.parentPageId}`, settings);
    return {
      message: t("background.parentPageAccessible")
    };
  }

  const { resolvedSettings, dataSource } = await getResolvedDataSource(settings);
  const properties = dataSource.properties || {};
  assertPropertyType(properties, "Name", "title");
  assertPropertyType(properties, "Tags", "multi_select");
  assertPropertyType(properties, "Source", "url");
  assertPropertyType(properties, "Created", "date");

  return {
    message: t("background.dataSourceAccessible", {
      target: resolvedSettings.targetType === "database" ? "Database" : "Data source"
    })
  };
}

async function createNotionPage(note, settings) {
  const targetSettings = getNotionSettingsForNote(note, settings);
  assertNotionSettings(targetSettings);
  const resolvedSettings = await resolveNotionSettings(targetSettings);
  return createNotionPageWithResolvedSettings(note, resolvedSettings);
}

function getNotionSettingsForNote(note, settings) {
  const route = ClipNoteStore.getMatchingNotionTagRoute(note, settings);
  if (!route) {
    return settings;
  }

  return {
    ...settings,
    targetType: route.targetType,
    parentPageId: route.parentPageId,
    dataSourceId: route.dataSourceId,
    databaseId: route.databaseId,
    matchedTagRoute: route
  };
}

function getNotionTargetCacheKey(settings) {
  return [
    settings.targetType,
    settings.parentPageId,
    settings.dataSourceId,
    settings.databaseId
  ].join(":");
}

async function resolveNotionSettingsForNote(note, settings, cache) {
  const targetSettings = getNotionSettingsForNote(note, settings);
  assertNotionSettings(targetSettings);
  const cacheKey = getNotionTargetCacheKey(targetSettings);
  if (!cache.has(cacheKey)) {
    cache.set(cacheKey, await resolveNotionSettings(targetSettings));
  }
  return cache.get(cacheKey);
}

async function createNotionPageWithResolvedSettings(note, resolvedSettings) {
  const children = ClipNoteStore.buildNotionChildren(note);
  const [initialChildren = [], ...remainingChildrenBatches] = chunkArray(
    children,
    MAX_NOTION_CHILDREN_PER_REQUEST
  );

  const notionPage = await requestNotion("/v1/pages", resolvedSettings, {
    method: "POST",
    body: JSON.stringify({
      parent: buildNotionParent(resolvedSettings),
      properties: buildNotionProperties(note, resolvedSettings),
      children: initialChildren
    })
  });

  for (const batch of remainingChildrenBatches) {
    await requestNotion(`/v1/blocks/${notionPage.id}/children`, resolvedSettings, {
      method: "PATCH",
      body: JSON.stringify({
        children: batch
      })
    });
  }

  return notionPage;
}

async function syncNoteToNotion(noteId) {
  if (isSyncingAllNotes) {
    return {
      status: "in_progress",
      noteId
    };
  }

  if (syncingNoteIds.has(noteId)) {
    return {
      status: "in_progress",
      noteId
    };
  }

  syncingNoteIds.add(noteId);
  try {
    const settings = await ClipNoteStore.getNotionSettings();
    const notes = await ClipNoteStore.getNotes();
    const note = notes.find((item) => item.id === noteId);
    if (!note) {
      throw new Error(t("background.noteNotFound"));
    }

    if (note.notionSyncedAt) {
      return {
        status: "skipped",
        reason: "already_synced",
        note
      };
    }

    const notionPage = await createNotionPage(note, settings);
    const updatedNote = await ClipNoteStore.updateNote(note.id, {
      notionPageUrl: notionPage.url || "",
      notionSyncedAt: new Date().toISOString()
    });
    return {
      status: "synced",
      note: updatedNote
    };
  } finally {
    syncingNoteIds.delete(noteId);
  }
}

async function syncAllNotesToNotion() {
  if (isSyncingAllNotes) {
    return {
      status: "in_progress",
      synced: 0,
      skipped: 0,
      failed: 0,
      failures: []
    };
  }

  isSyncingAllNotes = true;
  try {
    const settings = await ClipNoteStore.getNotionSettings();
    assertNotionSettings(settings);
    const resolvedSettingsCache = new Map();

    const notes = await ClipNoteStore.getNotes();
    const unsyncedNotes = notes.filter((note) => !note.notionSyncedAt);
    const results = [];
    const failures = [];

    for (const note of unsyncedNotes) {
      if (syncingNoteIds.has(note.id)) {
        failures.push({
          noteId: note.id,
          title: note.title,
          error: t("background.noteInProgress")
        });
        continue;
      }

      syncingNoteIds.add(note.id);
      try {
        const resolvedSettings = await resolveNotionSettingsForNote(
          note,
          settings,
          resolvedSettingsCache
        );
        const notionPage = await createNotionPageWithResolvedSettings(note, resolvedSettings);
        const updatedNote = await ClipNoteStore.updateNote(note.id, {
          notionPageUrl: notionPage.url || "",
          notionSyncedAt: new Date().toISOString()
        });
        results.push(updatedNote);
      } catch (error) {
        failures.push({
          noteId: note.id,
          title: note.title,
          error: error?.message || t("background.syncFailed")
        });
      } finally {
        syncingNoteIds.delete(note.id);
      }
    }

    return {
      status: failures.length ? "partial" : "synced",
      synced: results.length,
      skipped: notes.length - unsyncedNotes.length,
      failed: failures.length,
      failures
    };
  } finally {
    isSyncingAllNotes = false;
  }
}

chrome.runtime.onInstalled.addListener(async () => {
  try {
    await createContextMenu();
    await ClipNoteStore.addTags([ClipNoteStore.DEFAULT_TAG]);
  } catch (error) {
    console.warn("ClipNote install setup failed:", error);
  }
});

chrome.runtime.onStartup?.addListener(() => {
  createContextMenu().catch((error) => {
    console.warn("ClipNote menu refresh failed:", error);
  });
});

chrome.contextMenus.onClicked.addListener(async (info, tab) => {
  if (info.menuItemId !== MENU_ID) {
    return;
  }

  const text = String(info.selectionText || "").trim();
  if (!text) {
    return;
  }

  try {
    await saveDraftAndOpenTagDialog({
      text,
      url: info.pageUrl || tab?.url || "",
      title: tab?.title || t("background.untitledPage")
    });
  } catch (error) {
    console.warn("ClipNote save selection failed:", error);
  }
});

chrome.commands.onCommand.addListener((command) => {
  if (command !== "save-selection") {
    return;
  }

  saveActiveTabSelection().catch((error) => {
    console.warn("ClipNote shortcut save failed:", error);
  });
});

chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  if (message?.type === "SYNC_NOTE_TO_NOTION") {
    return sendMessageResponse(sendResponse, syncNoteToNotion(message.noteId));
  }

  if (message?.type === "SYNC_ALL_NOTES_TO_NOTION") {
    return sendMessageResponse(sendResponse, syncAllNotesToNotion());
  }

  if (message?.type === "TEST_NOTION_CONNECTION") {
    return sendMessageResponse(sendResponse, testNotionConnection());
  }

  if (message?.type === "UPDATE_I18N_LANGUAGE") {
    return sendMessageResponse(sendResponse, createContextMenu());
  }

  return false;
});