importNodes.ts

import type { Json } from "@repo/database/dbTypes";
import matter from "gray-matter";
import { App, Notice, TFile } from "obsidian";
import type { DGSupabaseClient } from "@repo/database/lib/client";
import type DiscourseGraphPlugin from "~/index";
import { getLoggedInClient, getSupabaseContext } from "./supabaseContext";
import type { DiscourseNode, ImportableNode } from "~/types";
import { QueryEngine } from "~/services/QueryEngine";
import {
  getImportedNodesInfo,
  getLocalNodeKeyToEndpointId,
} from "~/utils/relationsStore";
import { spaceUriAndLocalIdToRid } from "./rid";
import type { PostgrestResponse } from "@supabase/supabase-js";
import type { Tables } from "@repo/database/dbTypes";
import { getSpaceNameIdFromRid } from "./spaceFromRid";
import {
  importRelationsForImportedNodes,
  type RemoteRelationInstance,
} from "./importRelations";
import { createTemplateFile } from "./templates";
import { resolveFolderForSpaceUri } from "./importFolderMetadata";

type PublishedNode = {
  source_local_id: string;
  space_id: number;
  text: string;
  createdAt: number;
  modifiedAt: number;
  filePath: string | undefined;
  authorId: number | undefined;
};

export const getPublishedNodesForGroups = async ({
  client,
  groupIds,
  currentSpaceId,
}: {
  client: DGSupabaseClient;
  groupIds: string[];
  currentSpaceId: number;
}): Promise<Array<PublishedNode>> => {
  if (groupIds.length === 0) {
    return [];
  }

  // Query my_contents (RLS applied); exclude current space. Get both variants so we can use
  // the latest last_modified per node and prefer "direct" for text (title).
  const { data, error } = await client
    .from("my_contents")
    .select(
      "source_local_id, space_id, text, created, last_modified, variant, metadata, author_id",
    )
    .neq("space_id", currentSpaceId);

  if (error) {
    console.error("Error fetching published nodes:", error);
    throw new Error(`Failed to fetch published nodes: ${error.message}`);
  }

  if (!data || data.length === 0) {
    return [];
  }

  type Row = {
    source_local_id: string | null;
    space_id: number | null;
    text: string | null;
    created: string | null;
    last_modified: string | null;
    variant: string | null;
    author_id: number | null;
    metadata: Json;
  };

  const key = (r: Row) => `${r.space_id ?? ""}\t${r.source_local_id ?? ""}`;
  const groups = new Map<string, Row[]>();
  for (const row of data as Row[]) {
    if (row.source_local_id == null || row.space_id == null) continue;
    const k = key(row);
    if (!groups.has(k)) groups.set(k, []);
    groups.get(k)!.push(row);
  }

  const nodes: Array<PublishedNode> = [];

  for (const rows of groups.values()) {
    const withDate = rows.filter(
      (r) => r.last_modified != null && r.text != null,
    );
    if (withDate.length === 0) continue;
    const latest = withDate.reduce((a, b) =>
      (a.last_modified ?? "") >= (b.last_modified ?? "") ? a : b,
    );
    const direct = rows.find((r) => r.variant === "direct");
    const text = direct?.text ?? latest.text ?? "";
    const createdAt = latest.created
      ? new Date(latest.created + "Z").valueOf()
      : 0;
    const modifiedAt = latest.last_modified
      ? new Date(latest.last_modified + "Z").valueOf()
      : 0;
    const filePath: string | undefined =
      direct &&
      typeof direct.metadata === "object" &&
      typeof (direct.metadata as Record<string, any>).filePath === "string"
        ? (direct.metadata as Record<string, any>).filePath
        : undefined;
    nodes.push({
      source_local_id: latest.source_local_id!,
      space_id: latest.space_id!,
      text,
      createdAt,
      modifiedAt,
      filePath,
      authorId: latest.author_id ?? undefined,
    });
  }

  return nodes;
};

export const getLocalNodeInstanceIds = (
  plugin: DiscourseGraphPlugin,
): Set<string> => {
  const queryEngine = new QueryEngine(plugin.app);
  const files = queryEngine.getFilesWithNodeInstanceId();
  const nodeInstanceIds = new Set<string>();

  for (const file of files) {
    const cache = plugin.app.metadataCache.getFileCache(file);
    const frontmatter = cache?.frontmatter;
    if (frontmatter?.nodeInstanceId) {
      nodeInstanceIds.add(frontmatter.nodeInstanceId as string);
    }
  }

  return nodeInstanceIds;
};

/**
 * Returns the space name for a given space ID.
 * Falls back to "space-{id}" if the lookup fails.
 */
export const getSpaceNameFromId = async (
  client: DGSupabaseClient,
  spaceId: number,
): Promise<string> => {
  const { data, error } = await client
    .from("Space")
    .select("name")
    .eq("id", spaceId)
    .maybeSingle();

  if (error || !data) {
    console.error("Error fetching space name:", error);
    return `space-${spaceId}`;
  }

  return data.name;
};

export { getSpaceNameIdFromRid } from "./spaceFromRid";

export const getSpaceNameFromIds = async (
  client: DGSupabaseClient,
  spaceIds: number[],
): Promise<Map<number, string>> => {
  if (spaceIds.length === 0) {
    return new Map();
  }

  const { data, error } = (await client
    .from("my_spaces")
    .select("id, name")
    .in("id", spaceIds)) as PostgrestResponse<Tables<"Space">>;

  if (error) {
    console.error("Error fetching space names:", error);
    return new Map();
  }

  const spaceMap = new Map<number, string>();
  (data || []).forEach((space) => {
    spaceMap.set(space.id, space.name);
  });

  return spaceMap;
};

export const getSpaceUris = async (
  client: DGSupabaseClient,
  spaceIds: number[],
): Promise<Map<number, string>> => {
  if (spaceIds.length === 0) {
    return new Map();
  }

  const { data, error } = (await client
    .from("my_spaces")
    .select("id, url")
    .in("id", spaceIds)) as PostgrestResponse<Tables<"Space">>;

  if (error) {
    console.error("Error fetching space urls:", error);
    return new Map();
  }

  const spaceMap = new Map<number, string>();
  (data || []).forEach((space) => {
    spaceMap.set(space.id, space.url);
  });

  return spaceMap;
};

export const fetchUserNames = async (
  plugin: DiscourseGraphPlugin,
  client: DGSupabaseClient,
) => {
  const result = await client
    .from("my_accounts")
    .select("id, name")
    .eq("agent_type", "person");
  if (result.error || !result.data) {
    console.error(result.error);
    return;
  }
  const nameById = Object.fromEntries(
    result.data.map(({ id, name }) => [id, name]) as [number, string][],
  );
  plugin.settings.userNames = nameById;
  await plugin.saveSettings();
};

export const fetchNodeContent = async ({
  client,
  spaceId,
  nodeInstanceId,
  variant,
}: {
  client: DGSupabaseClient;
  spaceId: number;
  nodeInstanceId: string;
  variant: "direct" | "full";
}): Promise<string | null> => {
  const { data, error } = await client
    .from("my_contents")
    .select("text")
    .eq("source_local_id", nodeInstanceId)
    .eq("space_id", spaceId)
    .eq("variant", variant)
    .maybeSingle();

  if (error || !data || data.text == null) {
    console.error(
      `Error fetching node content (${variant}):`,
      error || "No data",
    );
    return null;
  }

  return data.text;
};

export const fetchNodeContentWithMetadata = async ({
  client,
  spaceId,
  nodeInstanceId,
  variant,
}: {
  client: DGSupabaseClient;
  spaceId: number;
  nodeInstanceId: string;
  variant: "direct" | "full";
}): Promise<{
  content: string;
  createdAt: number;
  modifiedAt: number;
} | null> => {
  const { data, error } = await client
    .from("my_contents")
    .select("text, created, last_modified")
    .eq("source_local_id", nodeInstanceId)
    .eq("space_id", spaceId)
    .eq("variant", variant)
    .maybeSingle();

  if (error || !data || data.text == null) {
    console.error(
      `Error fetching node content with metadata (${variant}):`,
      error || "No data",
    );
    return null;
  }

  return {
    content: data.text,
    createdAt: data.created ? new Date(data.created + "Z").valueOf() : 0,
    modifiedAt: data.last_modified
      ? new Date(data.last_modified + "Z").valueOf()
      : 0,
  };
};

/**
 * Fetches both direct (title) and full (body + dates) variants in one query.
 * Used by importSelectedNodes to avoid two round-trips to the content table.
 */
const fetchNodeContentForImport = async ({
  client,
  spaceId,
  nodeInstanceId,
}: {
  client: DGSupabaseClient;
  spaceId: number;
  nodeInstanceId: string;
}): Promise<{
  fileName: string;
  content: string;
  createdAt: number;
  modifiedAt: number;
  authorId: number;
  filePath?: string;
} | null> => {
  const { data, error } = await client
    .from("my_contents")
    .select("text, created, last_modified, variant, metadata, author_id")
    .eq("source_local_id", nodeInstanceId)
    .eq("space_id", spaceId)
    .in("variant", ["direct", "full"]);

  if (error) {
    console.error("Error fetching node content for import:", error);
    return null;
  }

  const rows = (data ?? []) as Array<{
    text: string | null;
    created: string | null;
    last_modified: string | null;
    author_id: number | null;
    variant: string | null;
    metadata: Json;
  }>;
  const direct = rows.find((r) => r.variant === "direct");
  const full = rows.find((r) => r.variant === "full");
  const authorId = full?.author_id ?? direct?.author_id ?? null;

  if (
    !direct?.text ||
    !full?.text ||
    full.created === null ||
    full.last_modified === null ||
    authorId === null
  ) {
    return null;
  }

  const filePath: string | undefined =
    typeof direct.metadata === "object" &&
    typeof (direct.metadata as Record<string, any>).filePath === "string"
      ? (direct.metadata as Record<string, any>).filePath
      : undefined;
  return {
    fileName: direct.text,
    content: full.text,
    createdAt: new Date(full.created + "Z").valueOf(),
    modifiedAt: new Date(full.last_modified + "Z").valueOf(),
    filePath,
    authorId,
  };
};

/**
 * Fetches created/last_modified from the source space Content (my_contents) for an imported node.
 * Used by the discourse context view to show "last modified in original vault".
 */
export const getSourceContentDates = async ({
  plugin,
  nodeInstanceId,
  importedFromRid,
}: {
  plugin: DiscourseGraphPlugin;
  nodeInstanceId: string;
  importedFromRid: string;
}): Promise<{ createdAt: string; modifiedAt: string } | null> => {
  const client = await getLoggedInClient(plugin);
  if (!client) return null;
  const { spaceId } = await getSpaceNameIdFromRid(client, importedFromRid);
  if (spaceId < 0) return null;
  const { data, error } = await client
    .from("my_contents")
    .select("created, last_modified")
    .eq("source_local_id", nodeInstanceId)
    .eq("space_id", spaceId)
    .eq("variant", "direct")
    .maybeSingle();
  if (error || !data) return null;
  return {
    createdAt: data.created ?? new Date(0).toISOString(),
    modifiedAt: data.last_modified ?? new Date(0).toISOString(),
  };
};

const fetchFileReferences = async ({
  client,
  spaceId,
  nodeInstanceId,
}: {
  client: DGSupabaseClient;
  spaceId: number;
  nodeInstanceId: string;
}): Promise<
  Array<{
    filepath: string;
    filehash: string;
    created: number;
    last_modified: number;
  }>
> => {
  const { data, error } = (await client
    .from("my_file_references")
    .select("filepath, filehash, created, last_modified")
    .eq("space_id", spaceId)
    .eq("source_local_id", nodeInstanceId)) as PostgrestResponse<
    Tables<"FileReference">
  >;

  if (error) {
    console.error("Error fetching file references:", error);
    return [];
  }

  return data.map(({ filepath, filehash, created, last_modified }) => ({
    filepath,
    filehash,
    created: created ? new Date(created + "Z").valueOf() : 0,
    last_modified: last_modified ? new Date(last_modified + "Z").valueOf() : 0,
  }));
};

const downloadFileFromStorage = async ({
  client,
  filehash,
}: {
  client: DGSupabaseClient;
  filehash: string;
}): Promise<ArrayBuffer | null> => {
  try {
    const { data, error } = await client.storage
      .from("assets")
      .download(filehash);

    if (error) {
      return null;
    }

    if (!data) {
      return null;
    }

    return await data.arrayBuffer();
  } catch (error) {
    console.error(`Exception downloading file ${filehash}:`, error);
    return null;
  }
};

/** Normalize path for lookup: strip leading "./", collapse slashes. Shared so pathMapping keys match link paths. */
const normalizePathForLookup = (p: string): string =>
  p.replace(/^\.\//, "").replace(/\/+/g, "/").trim();

const updateMarkdownAssetLinks = ({
  content,
  oldPathToNewPath,
  targetFile,
  app,
  originalNodePath,
}: {
  content: string;
  oldPathToNewPath: Map<string, string>;
  targetFile: TFile;
  app: App;
  originalNodePath?: string;
}): string => {
  // Create a set of all new paths for quick lookup (used by findImportedAssetFile when pathMapping has entries)
  const newPaths = new Set(oldPathToNewPath.values());

  let updatedContent = content;

  const noteDir = targetFile.path.includes("/")
    ? targetFile.path.replace(/\/[^/]*$/, "")
    : "";

  // When the note is under import/{spaceName}/, only treat wiki links as resolved if the target is in this folder (not some other vault file).
  const pathParts = targetFile.path.split("/");
  const importFolder =
    pathParts[0] === "import" && pathParts.length >= 2
      ? pathParts.slice(0, 2).join("/")
      : null;

  /** Path of targetFile relative to the current note, for use in links. Obsidian resolves relative links from the note's directory. */
  const getRelativeLinkPath = (assetPath: string): string => {
    const noteParts = noteDir ? noteDir.split("/").filter(Boolean) : [];
    const targetParts = assetPath.split("/").filter(Boolean);
    let i = 0;
    while (
      i < noteParts.length &&
      i < targetParts.length &&
      noteParts[i] === targetParts[i]
    ) {
      i++;
    }
    const ups = noteParts.length - i;
    const down = targetParts.slice(i);
    const segments = [...Array(ups).fill(".."), ...down];
    return segments.join("/");
  };

  // Resolve a path with ".." and "." segments relative to a base directory (vault-relative).
  const resolvePathRelativeToBase = (
    baseDir: string,
    relativePath: string,
  ): string => {
    const baseParts = baseDir ? baseDir.split("/").filter(Boolean) : [];
    const pathParts = relativePath.replace(/\/+/g, "/").trim().split("/");
    const result = [...baseParts];
    for (const part of pathParts) {
      if (part === "..") {
        result.pop();
      } else if (part !== "." && part !== "") {
        result.push(part);
      }
    }
    return result.join("/");
  };

  // Canonical form for matching link paths to oldPath (vault-relative, no import prefix).
  const getLinkCanonicalForMatch = (linkPath: string): string => {
    const resolved = resolvePathRelativeToBase(noteDir, linkPath);
    if (resolved.startsWith("import/")) {
      const segments = resolved.split("/");
      return segments.length > 2 ? segments.slice(2).join("/") : resolved;
    }
    return resolved;
  };

  // Resolve link relative to the source note's directory (for "path from current file" when imported note is flattened).
  const getCanonicalFromOriginalNote = (
    linkPath: string,
  ): string | undefined => {
    if (!originalNodePath) return undefined;
    const originalNoteDir = originalNodePath.includes("/")
      ? originalNodePath.replace(/\/[^/]*$/, "")
      : "";
    return normalizePathForLookup(
      resolvePathRelativeToBase(originalNoteDir, linkPath),
    );
  };

  // Look up new path by link as written in content: use canonical form (resolve relative + strip import prefix).
  const getNewPathForLink = (linkPath: string): string | undefined => {
    const canonical = normalizePathForLookup(
      getLinkCanonicalForMatch(linkPath),
    );
    const byCanonical = oldPathToNewPath.get(canonical);
    if (byCanonical) return byCanonical;
    const byRaw = oldPathToNewPath.get(normalizePathForLookup(linkPath));
    if (byRaw) return byRaw;
    // "Path from current file" in source: link was relative to source note; pathMapping keys are source vault-relative.
    const fromOriginal = getCanonicalFromOriginalNote(linkPath);
    return fromOriginal ? oldPathToNewPath.get(fromOriginal) : undefined;
  };

  // Helper to find file for a link path, checking if it's one of our imported assets
  const findImportedAssetFile = (linkPath: string): TFile | null => {
    // Try to resolve the link
    const resolvedFile = app.metadataCache.getFirstLinkpathDest(
      linkPath,
      targetFile.path,
    );

    if (resolvedFile && newPaths.has(resolvedFile.path)) {
      // This file is one of our imported assets
      return resolvedFile;
    }

    // Also check if the resolved file is in an assets folder (user may have renamed it)
    if (resolvedFile && resolvedFile.path.includes("/assets/")) {
      // Check if any of our new files match this one (by checking if path is similar)
      for (const newPath of newPaths) {
        const newFile = app.metadataCache.getFirstLinkpathDest(
          newPath,
          targetFile.path,
        );
        if (newFile && newFile.path === resolvedFile.path) {
          return resolvedFile;
        }
      }
    }

    return null;
  };

  const processLink = (linkPath: string): string => {
    // Skip external URLs
    if (linkPath.startsWith("http://") || linkPath.startsWith("https://")) {
      return linkPath;
    }

    // Separate file path from heading/block fragment (e.g. "Note.md#section" → filePath="Note.md", fragment="#section")
    // so that file resolution operates only on the file path portion.
    const hashIndex = linkPath.indexOf("#");
    const filePath = hashIndex !== -1 ? linkPath.slice(0, hashIndex) : linkPath;
    const fragment = hashIndex !== -1 ? linkPath.slice(hashIndex) : "";

    const resolveFilePath = (path: string): string => {
      // First, try to find if this link resolves to one of our imported assets
      const importedAssetFile = findImportedAssetFile(path);
      if (importedAssetFile) {
        return getRelativeLinkPath(importedAssetFile.path);
      }

      // Direct lookup from pathMapping (record built when we downloaded each asset)
      const newPath = getNewPathForLink(path);
      if (newPath) {
        const newFile = app.metadataCache.getFirstLinkpathDest(
          newPath,
          targetFile.path,
        );
        if (newFile) {
          return getRelativeLinkPath(newFile.path);
        }
      }

      // Only resolve to files under import/{spaceName}/ so we don't point at the wrong vault's files
      const resolvedFile = app.metadataCache.getFirstLinkpathDest(
        path,
        targetFile.path,
      );
      const isInImportFolder =
        importFolder &&
        resolvedFile &&
        resolvedFile.path.startsWith(importFolder + "/");
      if (isInImportFolder && resolvedFile) {
        return getRelativeLinkPath(resolvedFile.path);
      }

      // Unresolved (dead) link from another vault: rewrite so that when the user creates the file from this link, it is created under import/{vaultName}/ in the same relative position as in the source vault
      if (importFolder && originalNodePath && !resolvedFile) {
        // Vault-relative link (e.g. "Discourse Nodes/EVD - no relation testing") -> use as-is. Path-from-current-file (e.g. "EVD - no relation testing") -> resolve relative to source note dir
        const canonicalSourcePath =
          path.includes("/") && !path.startsWith(".") && !path.startsWith("/")
            ? normalizePathForLookup(path)
            : (getCanonicalFromOriginalNote(path) ??
              normalizePathForLookup(path));
        return `${importFolder}/${canonicalSourcePath}`;
      }

      return path;
    };

    return resolveFilePath(filePath) + fragment;
  };

  // Match wiki links: [[path]] or [[path|alias]]
  const wikiLinkRegex = /\[\[([^\]]+)\]\]/g;
  updatedContent = updatedContent.replace(
    wikiLinkRegex,
    (match, linkContent: string) => {
      // Extract path and optional alias
      const [linkPath, alias] = linkContent
        .split("|")
        .map((s: string) => s.trim());
      if (!linkPath) return match;
      let processedPath = processLink(linkPath);
      const hashIdx = processedPath.indexOf("#");
      const pathBeforeHash =
        hashIdx !== -1 ? processedPath.slice(0, hashIdx) : processedPath;
      const pathAfterHash = hashIdx !== -1 ? processedPath.slice(hashIdx) : "";
      if (pathBeforeHash.endsWith(".md") && !linkPath.endsWith(".md")) {
        processedPath = pathBeforeHash.slice(0, -3) + pathAfterHash;
      }
      if (alias) {
        return `[[${processedPath}|${alias}]]`;
      }
      return `[[${processedPath}|${linkPath}]]`;
    },
  );

  // Match markdown links (non-image): [text](path) — internal paths resolved like wikilinks, href kept URL-encoded
  const markdownLinkRegex = /(?<!!)\[([^\]]*)\]\(([^)]+)\)/g;
  updatedContent = updatedContent.replace(
    markdownLinkRegex,
    (match, linkText: string, linkPath: string) => {
      if (!linkPath) return match;
      linkPath = linkPath
        .split("/")
        .map((segment) => {
          try {
            return decodeURIComponent(segment);
          } catch {
            return segment;
          }
        })
        .join("/");
      if (linkPath.startsWith("http://") || linkPath.startsWith("https://")) {
        return match;
      }
      const processedPath = encodePathForMarkdownLink(processLink(linkPath));
      return `[${linkText}](${processedPath})`;
    },
  );

  // Match markdown image links: ![alt](path) or ![alt](path "title")
  const markdownImageRegex = /!\[([^\]]*)\]\(([^)]+)\)/g;
  updatedContent = updatedContent.replace(
    markdownImageRegex,
    (match, alt, linkPath) => {
      // Remove optional title from linkPath: "path" or "path title"
      const cleanPath = linkPath.replace(/\s+"[^"]*"$/, "").trim();

      // Skip external URLs
      if (cleanPath.startsWith("http://") || cleanPath.startsWith("https://")) {
        return match;
      }

      // First, try to find if this link resolves to one of our imported assets
      const importedAssetFile = findImportedAssetFile(cleanPath);
      if (importedAssetFile) {
        const linkText = getRelativeLinkPath(importedAssetFile.path);
        return `![${alt}](${linkText})`;
      }

      // Direct lookup from pathMapping (record built when we downloaded each asset)
      const newPath = getNewPathForLink(cleanPath);
      if (newPath) {
        const newFile = app.metadataCache.getFirstLinkpathDest(
          newPath,
          targetFile.path,
        );
        if (newFile) {
          const linkText = getRelativeLinkPath(newFile.path);
          return `![${alt}](${linkText})`;
        }
      }

      return match;
    },
  );

  return updatedContent;
};

/** Path of an asset relative to the note's directory (vault-relative). If asset is not under note dir, returns full path. */
const getAssetPathRelativeToNote = (
  assetFilePath: string,
  originalNodePath: string,
): string => {
  const noteDir = originalNodePath.includes("/")
    ? originalNodePath.replace(/\/[^/]*$/, "")
    : "";
  if (!noteDir || !assetFilePath.startsWith(`${noteDir}/`)) {
    return assetFilePath;
  }
  return assetFilePath.slice(noteDir.length + 1);
};

const importAssetsForNode = async ({
  plugin,
  client,
  spaceId,
  nodeInstanceId,
  importBasePath,
  targetMarkdownFile,
  originalNodePath,
}: {
  plugin: DiscourseGraphPlugin;
  client: DGSupabaseClient;
  spaceId: number;
  nodeInstanceId: string;
  importBasePath: string;
  targetMarkdownFile: TFile;
  /** Source vault path of the note (e.g. from Content metadata filePath). Used to place assets under import/{space}/ relative to note. */
  originalNodePath?: string;
}): Promise<{
  success: boolean;
  pathMapping: Map<string, string>; // old path -> new path
  errors: string[];
}> => {
  const pathMapping = new Map<string, string>();
  const errors: string[] = [];
  const stat = {
    ctime: targetMarkdownFile.stat.ctime,
    mtime: targetMarkdownFile.stat.mtime,
  };

  const setPathMapping = (oldPath: string, newPath: string): void => {
    pathMapping.set(oldPath, newPath);
    pathMapping.set(normalizePathForLookup(oldPath), newPath);
  };

  // Fetch FileReference records for the node
  const fileReferences = await fetchFileReferences({
    client,
    spaceId,
    nodeInstanceId,
  });

  if (fileReferences.length === 0) {
    return { success: true, pathMapping, errors };
  }

  // Get existing asset mappings from frontmatter
  const cache = plugin.app.metadataCache.getFileCache(targetMarkdownFile);
  const frontmatter = (cache?.frontmatter as Record<string, unknown>) || {};
  const importedAssetsRaw = frontmatter.importedAssets;
  const importedAssets: Record<string, string> =
    importedAssetsRaw &&
    typeof importedAssetsRaw === "object" &&
    !Array.isArray(importedAssetsRaw)
      ? (importedAssetsRaw as Record<string, string>)
      : {};
  // importedAssets format: { filehash: vaultPath }

  // Process each file reference
  for (const fileRef of fileReferences) {
    try {
      const { filepath, filehash } = fileRef;

      // Check if we already have a file for this hash
      const existingAssetPath: string | undefined = importedAssets[filehash];
      let existingFile: TFile | null = null;

      if (existingAssetPath) {
        // Check if the file still exists at the stored path
        const file = plugin.app.vault.getAbstractFileByPath(existingAssetPath);
        if (file && file instanceof TFile) {
          existingFile = file;
        }
      }

      let overwritePath: string | undefined;
      if (existingFile) {
        const refLastModifiedMs = fileRef.last_modified || 0;
        const localModifiedAfterRef =
          refLastModifiedMs > 0 && existingFile.stat.mtime > refLastModifiedMs;
        if (!localModifiedAfterRef) {
          setPathMapping(filepath, existingFile.path);
          continue;
        }
        overwritePath = existingFile.path;
      }

      // Target path: import/{spaceName}/{path relative to note}. If sourceNotePath is set and asset
      // is under the note's directory, use that relative path so assets sit under import/{space}/.
      const pathForImport =
        originalNodePath !== undefined
          ? getAssetPathRelativeToNote(filepath, originalNodePath)
          : filepath;
      const sanitizedAssetPath = pathForImport
        .split("/")
        .map(sanitizeFileName)
        .join("/");
      const targetPath =
        overwritePath ?? `${importBasePath}/${sanitizedAssetPath}`;

      // Ensure all parent folders exist before writing
      const pathParts = targetPath.split("/");
      for (let i = 1; i < pathParts.length - 1; i++) {
        const folderPath = pathParts.slice(0, i + 1).join("/");
        if (!(await plugin.app.vault.adapter.exists(folderPath))) {
          await plugin.app.vault.createFolder(folderPath);
        }
      }

      // If local mtime is newer than fileRef.last_modified, overwrite with DB version.
      if (await plugin.app.vault.adapter.exists(targetPath)) {
        const file = plugin.app.vault.getAbstractFileByPath(targetPath);
        if (file && file instanceof TFile) {
          const localMtimeMs = file.stat.mtime;
          const refLastModifiedMs = fileRef.last_modified || 0;
          const localModifiedAfterRef =
            refLastModifiedMs > 0 && localMtimeMs > refLastModifiedMs;
          const remoteIsNewer =
            refLastModifiedMs > 0 && refLastModifiedMs > localMtimeMs;
          if (!localModifiedAfterRef && !remoteIsNewer) {
            setPathMapping(filepath, targetPath);
            await plugin.app.fileManager.processFrontMatter(
              targetMarkdownFile,
              (fm) => {
                const assetsRaw = (fm as Record<string, unknown>)
                  .importedAssets;
                const assets: Record<string, string> =
                  assetsRaw &&
                  typeof assetsRaw === "object" &&
                  !Array.isArray(assetsRaw)
                    ? (assetsRaw as Record<string, string>)
                    : {};
                assets[filehash] = targetPath;
                (fm as Record<string, unknown>).importedAssets = assets;
              },
              stat,
            );
            continue;
          }
          // Local file was modified OR remote is newer; overwrite with DB version
        }
      }

      // File doesn't exist, download it
      const fileContent = await downloadFileFromStorage({
        client,
        filehash,
      });

      if (!fileContent) {
        errors.push(`Failed to download file: ${filepath}`);
        continue;
      }

      const options = { mtime: fileRef.last_modified, ctime: fileRef.created };
      // Save file to vault
      const existingFileForOverwrite =
        plugin.app.vault.getAbstractFileByPath(targetPath);
      if (
        existingFileForOverwrite &&
        existingFileForOverwrite instanceof TFile
      ) {
        await plugin.app.vault.modifyBinary(
          existingFileForOverwrite,
          fileContent,
          options,
        );
      } else {
        await plugin.app.vault.createBinary(targetPath, fileContent, options);
      }

      // Update frontmatter to track this mapping
      await plugin.app.fileManager.processFrontMatter(
        targetMarkdownFile,
        (fm) => {
          const assetsRaw = (fm as Record<string, unknown>).importedAssets;
          const assets: Record<string, string> =
            assetsRaw &&
            typeof assetsRaw === "object" &&
            !Array.isArray(assetsRaw)
              ? (assetsRaw as Record<string, string>)
              : {};
          assets[filehash] = targetPath;
          (fm as Record<string, unknown>).importedAssets = assets;
        },
        stat,
      );

      // Track path mapping (raw + normalized key so updateMarkdownAssetLinks can lookup by link text)
      setPathMapping(filepath, targetPath);
    } catch (error) {
      const errorMsg = `Error importing asset ${fileRef.filepath}: ${error}`;
      errors.push(errorMsg);
      console.error(errorMsg, error);
    }
  }

  return {
    success: errors.length === 0 || pathMapping.size > 0,
    pathMapping,
    errors,
  };
};

const sanitizeFileName = (fileName: string): string => {
  // Remove invalid characters for file names
  return fileName
    .replace(/[<>:"/\\|?*]/g, "")
    .replace(/\s+/g, " ")
    .trim();
};

/** Sanitize each path segment for use under import folder (preserves source vault folder structure). */
const sanitizePathForImport = (path: string): string => {
  return path
    .split("/")
    .map((segment) => sanitizeFileName(segment))
    .filter(Boolean)
    .join("/");
};

type ParsedFrontmatter = {
  nodeTypeId?: string;
  nodeInstanceId?: string;
  publishedToGroups?: string[];
  authorId?: number;
  [key: string]: unknown;
};

const parseFrontmatter = (
  content: string,
): { frontmatter: ParsedFrontmatter; body: string } => {
  const { data, content: body } = matter(content);
  return {
    frontmatter: (data ?? {}) as ParsedFrontmatter,
    body: body ?? "",
  };
};

/**
 * Parse literal_content from a Concept schema into fields for DiscourseNode.
 * Handles both nested form { label, template, source_data: { format, color, tag } }
 * and flat form { id, name, color, format, tag }.
 */
const parseSchemaLiteralContent = (
  literalContent: unknown,
  fallbackName: string,
): Pick<
  DiscourseNode,
  "name" | "format" | "color" | "tag" | "template" | "keyImage"
> & { templateContent?: string } => {
  const obj =
    typeof literalContent === "string"
      ? (JSON.parse(literalContent) as Record<string, unknown>)
      : (literalContent as Record<string, unknown>) || {};
  const src = (obj.source_data as Record<string, unknown>) || obj;
  const name = (obj.name as string) || (obj.label as string) || fallbackName;
  const formatFromSchema =
    (src.format as string) || (obj.format as string) || "";
  const format =
    formatFromSchema || `${name.slice(0, 3).toUpperCase()} - {content}`;
  return {
    name,
    format,
    color: (src.color as string) || (obj.color as string) || undefined,
    tag: (src.tag as string) || (obj.tag as string) || undefined,
    template: (obj.template as string) || undefined,
    templateContent: (obj.template_content as string) || undefined,
    keyImage:
      (src.keyImage as boolean) ?? (obj.keyImage as boolean) ?? undefined,
  };
};

export const mapNodeTypeIdToLocal = async ({
  plugin,
  client,
  sourceSpaceId,
  sourceSpaceUri,
  sourceNodeTypeId,
}: {
  plugin: DiscourseGraphPlugin;
  client: DGSupabaseClient;
  sourceSpaceId: number;
  sourceSpaceUri: string;
  sourceNodeTypeId: string;
}): Promise<string> => {
  // Find the schema in the source space with this nodeTypeId (my_concepts applies RLS)
  const { data: schemaData } = await client
    .from("my_concepts")
    .select("name, literal_content, author_id")
    .eq("space_id", sourceSpaceId)
    .eq("is_schema", true)
    .eq("source_local_id", sourceNodeTypeId)
    .maybeSingle();

  if (!schemaData?.name) {
    return sourceNodeTypeId;
  }

  const schemaName = schemaData.name;

  // Prefer match by node type ID (imported type may already exist locally with same id)
  const matchById = plugin.settings.nodeTypes.find(
    (nt) => nt.id === sourceNodeTypeId,
  );
  if (matchById) {
    return matchById.id;
  }

  // Fall back to match by name
  const matchingLocalNodeType = plugin.settings.nodeTypes.find(
    (nt) => nt.name === schemaName,
  );
  if (matchingLocalNodeType) {
    return matchingLocalNodeType.id;
  }

  // No matching local nodeType: create one from literal_content and add to settings
  const parsed = parseSchemaLiteralContent(
    schemaData.literal_content,
    schemaName,
  );

  const now = new Date().getTime();
  const importedFromRid = spaceUriAndLocalIdToRid(
    sourceSpaceUri,
    sourceNodeTypeId,
    "schema",
  );

  const newNodeType: DiscourseNode = {
    id: sourceNodeTypeId,
    name: parsed.name,
    format: parsed.format,
    color: parsed.color,
    tag: parsed.tag,
    template: parsed.template,
    keyImage: parsed.keyImage,
    created: now,
    modified: now,
    authorId: schemaData.author_id ?? undefined,
    importedFromRid,
  };

  if (parsed.templateContent && parsed.template) {
    const result = await createTemplateFile({
      app: plugin.app,
      templateName: parsed.template,
      content: parsed.templateContent,
    });
    if (result.created) {
      new Notice(
        `Template "${parsed.template}" created for imported node type "${parsed.name}".`,
        4000,
      );
    } else if (
      result.reason === "Templates plugin is not enabled" ||
      result.reason === "Templates folder path is not configured"
    ) {
      // Don't store a template filename that can never resolve
      newNodeType.template = undefined;
      new Notice(
        `Node type "${parsed.name}" imported without template: ${result.reason}. Configure the Templates plugin to use templates.`,
        6000,
      );
    }
    // If reason is "template already exists", keep newNodeType.template — local file takes precedence
  }

  plugin.settings.nodeTypes = [...plugin.settings.nodeTypes, newNodeType];
  await plugin.saveSettings();
  return newNodeType.id;
};

const processFileContent = async ({
  plugin,
  client,
  sourceSpaceId,
  sourceSpaceUri,
  rawContent,
  originalFilePath,
  filePath,
  importedCreatedAt,
  importedModifiedAt,
  authorId,
}: {
  plugin: DiscourseGraphPlugin;
  client: DGSupabaseClient;
  sourceSpaceId: number;
  sourceSpaceUri: string;
  rawContent: string;
  originalFilePath?: string;
  filePath: string;
  importedCreatedAt?: number;
  importedModifiedAt?: number;
  authorId?: number;
}): Promise<
  { file: TFile; error?: never } | { file?: never; error: string }
> => {
  // 1. Create or update the file with the fetched content first.
  // On create, set file metadata (ctime/mtime) to original vault dates via vault adapter.
  let file: TFile | null = plugin.app.vault.getFileByPath(filePath);
  const stat =
    importedCreatedAt !== undefined && importedModifiedAt !== undefined
      ? {
          ctime: importedCreatedAt,
          mtime: importedModifiedAt,
        }
      : undefined;
  if (!file) {
    file = await plugin.app.vault.create(filePath, rawContent, stat);
  } else {
    await plugin.app.vault.process(file, () => rawContent, stat);
  }

  // 2. Parse frontmatter from rawContent (metadataCache is updated async and is
  //    often empty immediately after create/modify), then map nodeTypeId and update frontmatter.
  const { frontmatter } = parseFrontmatter(rawContent);
  const sourceNodeTypeId = frontmatter.nodeTypeId;
  if (typeof sourceNodeTypeId !== "string") {
    await plugin.app.vault.delete(file);
    return {
      error: "importedNode missing sourceNodeTypeId",
    };
  }
  const sourceNodeId = frontmatter.nodeInstanceId;
  if (typeof sourceNodeId !== "string") {
    await plugin.app.vault.delete(file);
    return {
      error: "importedNode missing nodeInstanceId",
    };
  }

  const mappedNodeTypeId = await mapNodeTypeIdToLocal({
    plugin,
    client,
    sourceSpaceId,
    sourceSpaceUri,
    sourceNodeTypeId,
  });

  await plugin.app.fileManager.processFrontMatter(
    file,
    (fm) => {
      const record = fm as Record<string, unknown>;
      if (mappedNodeTypeId !== undefined) {
        record.nodeTypeId = mappedNodeTypeId;
      }
      record.importedFromRid = spaceUriAndLocalIdToRid(
        sourceSpaceUri,
        sourceNodeId,
        "note",
      );
      record.lastModified = importedModifiedAt;
      if (authorId) record.authorId = authorId;
    },
    stat,
  );

  return { file };
};

export const importSelectedNodes = async ({
  plugin,
  selectedNodes,
  onProgress,
  precomputedData,
}: {
  plugin: DiscourseGraphPlugin;
  selectedNodes: ImportableNode[];
  onProgress?: (current: number, total: number) => void;
  precomputedData?: {
    nodeKeys: Set<string>;
    keyToRid: Map<string, string>;
    keyToRelationEndpointId: Map<string, string>;
    relationInstancesBySpace: Map<number, RemoteRelationInstance[]>;
  };
}): Promise<{ success: number; failed: number }> => {
  const client = await getLoggedInClient(plugin);
  if (!client) {
    throw new Error("Cannot get Supabase client");
  }

  const context = await getSupabaseContext(plugin);
  if (!context) {
    throw new Error("Cannot get Supabase context");
  }

  const queryEngine = new QueryEngine(plugin.app);

  let successCount = 0;
  let failedCount = 0;
  let processedCount = 0;
  const totalNodes = selectedNodes.length;

  // Group nodes by space to create folders efficiently
  const nodesBySpace = new Map<number, ImportableNode[]>();
  for (const node of selectedNodes) {
    if (!nodesBySpace.has(node.spaceId)) {
      nodesBySpace.set(node.spaceId, []);
    }
    nodesBySpace.get(node.spaceId)!.push(node);
  }

  const spaceUris = await getSpaceUris(client, [...nodesBySpace.keys()]);
  const spaceNames = await getSpaceNameFromIds(client, [
    ...nodesBySpace.keys(),
  ]);

  // Process each space
  for (const [spaceId, nodes] of nodesBySpace.entries()) {
    const spaceUri = spaceUris.get(spaceId);
    if (!spaceUri) {
      for (const _node of nodes) {
        failedCount++;
        processedCount++;
        onProgress?.(processedCount, totalNodes);
      }
      continue;
    }

    const spaceName = spaceNames.get(spaceId) ?? `space-${spaceId}`;
    const importFolderPath = await resolveFolderForSpaceUri({
      adapter: plugin.app.vault.adapter,
      spaceUri,
      spaceName,
    });

    // Process each node in this space
    for (const node of nodes) {
      try {
        const importedFromRid = spaceUriAndLocalIdToRid(
          spaceUri,
          node.nodeInstanceId,
          "note",
        );
        // Check if file already exists by nodeInstanceId + importedFromRid
        const existingFile = queryEngine.findExistingImportedFile(
          node.nodeInstanceId,
          importedFromRid,
        );

        const nodeContent = await fetchNodeContentForImport({
          client,
          spaceId,
          nodeInstanceId: node.nodeInstanceId,
        });

        if (!nodeContent) {
          failedCount++;
          processedCount++;
          onProgress?.(processedCount, totalNodes);
          continue;
        }

        const {
          fileName,
          content,
          createdAt: contentCreatedAt,
          modifiedAt: contentModifiedAt,
          filePath: contentFilePath,
          authorId,
        } = nodeContent;
        const createdAt = node.createdAt ?? contentCreatedAt;
        const modifiedAt = node.modifiedAt ?? contentModifiedAt;
        // Use source vault path from Content direct variant metadata for wikilink rewriting and asset placement
        const originalNodePath: string | undefined =
          contentFilePath ?? node.filePath;

        // Sanitize file name
        const sanitizedFileName = sanitizeFileName(fileName);
        let finalFilePath: string;

        if (existingFile) {
          // Update existing file - use its current path
          finalFilePath = existingFile.path;
        } else {
          // Preserve source vault folder structure under import/{vaultName} when we have filePath from Content
          const pathUnderImport =
            contentFilePath && contentFilePath.includes("/")
              ? sanitizePathForImport(contentFilePath)
              : `${sanitizedFileName}.md`;
          finalFilePath = `${importFolderPath}/${pathUnderImport}`;

          // Ensure all parent folders exist (e.g. import/VaultName/Discourse Nodes/SubFolder)
          const dirParts = finalFilePath.split("/");
          for (let i = 1; i < dirParts.length - 1; i++) {
            const folderPath = dirParts.slice(0, i + 1).join("/");
            if (!(await plugin.app.vault.adapter.exists(folderPath))) {
              await plugin.app.vault.createFolder(folderPath);
            }
          }
        }

        // Process the file content (maps nodeTypeId, handles frontmatter, stores import timestamps)
        // This updates existing file or creates new one
        const result = await processFileContent({
          plugin,
          client,
          sourceSpaceId: spaceId,
          sourceSpaceUri: spaceUri,
          rawContent: content,
          originalFilePath: contentFilePath,
          filePath: finalFilePath,
          importedCreatedAt: createdAt,
          importedModifiedAt: modifiedAt,
          authorId,
        });

        if (result.error) {
          console.error(
            `Error processing file content for node ${node.nodeInstanceId}:`,
            result.error,
          );
          failedCount++;
          processedCount++;
          onProgress?.(processedCount, totalNodes);
          continue;
        }

        // typescript should not need this assertion?
        const processedFile = result.file!;

        // Import assets for this node (use originalNodePath so assets go under import/{space}/ relative to note)
        const assetImportResult = await importAssetsForNode({
          plugin,
          client,
          spaceId,
          nodeInstanceId: node.nodeInstanceId,
          importBasePath: importFolderPath,
          targetMarkdownFile: processedFile,
          originalNodePath,
        });

        // Update markdown content: rewrite asset paths from pathMapping and normalize all wiki links to relative paths
        const currentContent = await plugin.app.vault.read(processedFile);
        const updatedContent = updateMarkdownAssetLinks({
          content: currentContent,
          oldPathToNewPath: assetImportResult.pathMapping,
          targetFile: processedFile,
          app: plugin.app,
          originalNodePath,
        });

        // Only update if content changed
        if (updatedContent !== currentContent) {
          await plugin.app.vault.process(processedFile, () => updatedContent);
        }

        // If title changed and file exists, rename it to match the new title
        if (existingFile && processedFile.basename !== sanitizedFileName) {
          const currentDir = processedFile.path.includes("/")
            ? processedFile.path.replace(/\/[^/]*$/, "")
            : importFolderPath;
          const newPath = `${currentDir}/${sanitizedFileName}.md`;
          let targetPath = newPath;
          let counter = 1;
          while (await plugin.app.vault.adapter.exists(targetPath)) {
            targetPath = `${currentDir}/${sanitizedFileName} (${counter}).md`;
            counter++;
          }
          await plugin.app.fileManager.renameFile(processedFile, targetPath);
        }

        successCount++;
        processedCount++;
        onProgress?.(processedCount, totalNodes);
      } catch (error) {
        console.error(`Error importing node ${node.nodeInstanceId}:`, error);
        failedCount++;
        processedCount++;
        onProgress?.(processedCount, totalNodes);
      }
    }

    // Import relations where both endpoints resolve in this vault (imported or local)
    try {
      let keyToRelationEndpointId: Map<string, string>;
      if (precomputedData?.keyToRelationEndpointId) {
        keyToRelationEndpointId = precomputedData.keyToRelationEndpointId;
      } else {
        const { keyToRid } = precomputedData
          ? { keyToRid: precomputedData.keyToRid }
          : await getImportedNodesInfo({
              queryEngine,
              plugin,
              client,
            });
        const localMap = getLocalNodeKeyToEndpointId(plugin, context.spaceId);
        keyToRelationEndpointId = new Map([...keyToRid, ...localMap]);
      }
      const precomputedRelationInstances =
        precomputedData?.relationInstancesBySpace.get(spaceId);
      const { imported } = await importRelationsForImportedNodes({
        plugin,
        client,
        spaceId,
        spaceUri,
        keyToRelationEndpointId,
        precomputedRelationInstances,
      });
      if (imported > 0) {
        console.debug(`Imported ${imported} relation(s) for space ${spaceId}`);
      }
    } catch (error) {
      console.warn("Failed to import relations for imported nodes:", error);
    }
  }

  return { success: successCount, failed: failedCount };
};

/**
 * Refresh a single imported file by fetching the latest content from the database
 * Reuses the same logic as importSelectedNodes by treating it as a single-node import
 */
export const refreshImportedFile = async ({
  plugin,
  file,
  client,
}: {
  plugin: DiscourseGraphPlugin;
  file: TFile;
  client?: DGSupabaseClient;
}): Promise<{ success: boolean; error?: string }> => {
  const supabaseClient = client || (await getLoggedInClient(plugin));
  if (!supabaseClient) {
    throw new Error("Cannot get Supabase client");
  }
  const cache = plugin.app.metadataCache.getFileCache(file);
  const frontmatter = cache?.frontmatter as Record<string, unknown> | undefined;
  if (!frontmatter?.importedFromRid || !frontmatter?.nodeInstanceId) {
    return {
      success: false,
      error: "Missing frontmatter: importedFromRid or nodeInstanceId",
    };
  }
  if (
    typeof frontmatter.importedFromRid !== "string" ||
    typeof frontmatter.nodeInstanceId !== "string"
  ) {
    return {
      success: false,
      error: "Non-string frontmatter: importedFromRid or nodeInstanceId",
    };
  }
  const { spaceName, spaceId } = await getSpaceNameIdFromRid(
    supabaseClient,
    frontmatter.importedFromRid,
  );
  if (spaceId === -1) {
    return { success: false, error: "Could not get the space Id" };
  }
  const metadataResp = await supabaseClient
    .from("Content")
    .select("metadata")
    .eq("space_id", spaceId)
    .eq("source_local_id", frontmatter.nodeInstanceId)
    .eq("variant", "direct")
    .maybeSingle();
  const metadata = metadataResp.data?.metadata;
  const filePath: string | undefined =
    typeof metadata === "object" &&
    typeof (metadata as Record<string, unknown>).filePath === "string"
      ? ((metadata as Record<string, unknown>).filePath as string)
      : undefined;
  const result = await importSelectedNodes({
    plugin,
    selectedNodes: [
      {
        nodeInstanceId: frontmatter.nodeInstanceId,
        title: file.basename,
        spaceId,
        spaceName,
        filePath,
        groupId:
          (frontmatter.publishedToGroups as string[] | undefined)?.[0] ?? "",
        selected: false,
      },
    ],
  });
  return {
    success: result.success > 0,
    error: result.failed > 0 ? "Failed to refresh imported file" : undefined,
  };
};

/**
 * Refresh all imported files in the vault
 */
export const refreshAllImportedFiles = async (
  plugin: DiscourseGraphPlugin,
): Promise<{
  success: number;
  failed: number;
  errors: Array<{ file: string; error: string }>;
}> => {
  const queryEngine = new QueryEngine(plugin.app);
  const importedFiles = queryEngine.getImportedNodePages();
  const client = await getLoggedInClient(plugin);
  if (!client) {
    throw new Error("Cannot get Supabase client");
  }

  if (importedFiles.length === 0) {
    return { success: 0, failed: 0, errors: [] };
  }

  let successCount = 0;
  let failedCount = 0;
  const errors: Array<{ file: string; error: string }> = [];

  // Refresh each file
  for (const file of importedFiles) {
    const result = await refreshImportedFile({ plugin, file, client });
    if (result.success) {
      successCount++;
    } else {
      failedCount++;
      errors.push({
        file: file.path,
        error: result.error || "Unknown error",
      });
    }
  }

  return { success: successCount, failed: failedCount, errors };
};

const encodePathForMarkdownLink = (linkPath: string): string => {
  // Input is already decoded; encode each segment (spaces → %20) but keep / as separator.
  // Split on the first # to preserve heading/block fragments (e.g. "Note.md#section" → "Note.md#section", not "Note.md%23section").
  const hashIndex = linkPath.indexOf("#");
  if (hashIndex === -1) {
    return linkPath
      .split("/")
      .map((segment) => encodeURIComponent(segment))
      .join("/");
  }
  const pathPart = linkPath.slice(0, hashIndex);
  const fragment = linkPath.slice(hashIndex); // includes the leading #
  const encodedPath = pathPart
    .split("/")
    .map((segment) => encodeURIComponent(segment))
    .join("/");
  return encodedPath + fragment;
};