conceptConversion.ts

import { InputTextNode } from "roamjs-components/types";
import getBlockProps from "./getBlockProps";
import { DiscourseNode } from "./getDiscourseNodes";
import getDiscourseRelations from "./getDiscourseRelations";
import type { DiscourseRelation } from "./getDiscourseRelations";
import type { SupabaseContext } from "~/utils/supabaseContext";
import { DISCOURSE_GRAPH_PROP_NAME } from "~/utils/createReifiedBlock";

import type { LocalConceptDataInput } from "@repo/database/inputTypes";
import type { Json } from "@repo/database/dbTypes";
import getPageTitleByPageUid from "roamjs-components/queries/getPageTitleByPageUid";

const getNodeExtraData = (
  node_uid: string,
): {
  author_uid: string;
  created: string;
  last_modified: string;
  page_uid: string;
  /* eslint-enable @typescript-eslint/naming-convention */
} => {
  const result = window.roamAlphaAPI.q(
    `[
    :find
      ?author_uid
      ?page_uid
      ?created
      ?last_modified
      :in $ ?block_uid
      :where
      [?block :block/uid ?block_uid]
      [?block :create/user ?author_id]
      [?author_id :user/uid ?author_uid]
      [?block :create/time ?created]
      [(get-else $ ?block :edit/time ?created) ?last_modified]
      [(get-else $ ?block :block/page ?block) ?page_id]
      [?page_id :block/uid ?page_uid]
  ]`,
    node_uid,
  );
  if (result.length !== 1 || result[0].length !== 4)
    throw new Error("Invalid result from Roam query");

  const [author_uid, page_uid, created_t, last_modified_t] = result[0] as [
    string,
    string,
    number,
    number,
  ];
  const created = new Date(created_t).toISOString();
  const last_modified = new Date(last_modified_t).toISOString();
  return {
    author_uid,
    created,
    last_modified,
    page_uid,
  };
  /* eslint-enable @typescript-eslint/naming-convention */
};

const indent = (s: string): string =>
  s
    .split("\n")
    .map((l) => "   " + l)
    .join("\n") + "\n";

const templateToText = (template: InputTextNode[]): string =>
  template
    .filter((itn) => !itn.text.startsWith("{{"))
    .map(
      (itn) =>
        `* ${itn.text}\n${itn.children?.length ? indent(templateToText(itn.children)) : ""}`,
    )
    .join("");

export const discourseNodeSchemaToLocalConcept = (
  context: SupabaseContext,
  node: DiscourseNode,
): LocalConceptDataInput => {
  const titleParts = node.text.split("/");
  const label = titleParts[titleParts.length - 1] ?? node.text;
  const result: LocalConceptDataInput = {
    space_id: context.spaceId,
    name: node.text,
    source_local_id: node.type,
    is_schema: true,
    literal_content: {
      label,
    },
    /* eslint-enable @typescript-eslint/naming-convention */
    ...getNodeExtraData(node.type),
  };
  if (node.template !== undefined)
    result.literal_content = {
      label,
      template: templateToText(node.template),
    };
  return result;
};

export const discourseNodeBlockToLocalConcept = (
  context: SupabaseContext,
  {
    nodeUid,
    schemaUid,
    text,
  }: {
    nodeUid: string;
    schemaUid: string;
    text: string;
  },
): LocalConceptDataInput => {
  return {
    space_id: context.spaceId,
    name: text,
    source_local_id: nodeUid,
    schema_represented_by_local_id: schemaUid,
    is_schema: false,
    /* eslint-enable @typescript-eslint/naming-convention */
    ...getNodeExtraData(nodeUid),
  };
};

const STANDARD_ROLES = ["source", "destination"];

export const discourseRelationSchemaToLocalConcept = (
  context: SupabaseContext,
  relation: DiscourseRelation,
): LocalConceptDataInput => {
  const { id, label, complement, source, destination, ...otherData } = relation;
  return {
    space_id: context.spaceId,
    source_local_id: id,
    name: getPageTitleByPageUid(id),
    is_schema: true,
    local_reference_content: {
      source,
      destination,
    },
    literal_content: {
      source_data: otherData as unknown as Json,
      /* eslint-enable @typescript-eslint/naming-convention */
      roles: STANDARD_ROLES,
      label: label,
      complement: complement,
    },
    ...getNodeExtraData(id),
  };
};

export const discourseRelationDataToLocalConcept = (
  context: SupabaseContext,
  relationUid: string,
): LocalConceptDataInput => {
  // assuming reified
  const relationProps = getBlockProps(relationUid);
  const relationSchemaData = relationProps[DISCOURSE_GRAPH_PROP_NAME] as Record<
    string,
    string
  >;
  if (!relationSchemaData) {
    throw new Error(`Missing relation data for ${relationUid}`);
  }
  const relationSchemaUid = relationSchemaData.hasSchema;
  if (!relationSchemaUid) {
    throw new Error(`Missing relation schema uid for ${relationUid}`);
  }
  const roamRelation = getDiscourseRelations().find(
    (r) => r.id === relationSchemaUid,
  );
  if (roamRelation === undefined) {
    throw new Error(`Invalid roam relation id ${relationSchemaUid}`);
  }
  const relation = discourseRelationSchemaToLocalConcept(context, roamRelation);
  const litContent = (
    relation.literal_content ? relation.literal_content : {}
  ) as { [key: string]: Json };
  const roles = (litContent["roles"] as string[] | undefined) || STANDARD_ROLES;
  const casting = Object.fromEntries(
    roles
      .map((role) => [role, relationSchemaData[role + "Uid"]])
      .filter(([, uid]) => uid !== undefined),
  ) as { [role: string]: string };
  if (Object.keys(casting).length === 0) {
    throw new Error(
      `No valid node UIDs supplied for roles ${roles.join(", ")}`,
    );
  }
  // TODO: Also get the nodes from the representation, using QueryBuilder. That will likely give me the relation object
  const nodeData = Object.values(casting).map((v) => getNodeExtraData(v));
  // roundabout way to do a max from stringified dates
  const last_modified = new Date(
    Math.max(...nodeData.map((nd) => new Date(nd.last_modified).getTime())),
  ).toISOString();
  // creation is actually creation of the relation node, not the rest of the cast, but this will do as a first approximation.
  // Still using max, since the relation cannot be created before its cast
  const created = new Date(
    Math.max(...nodeData.map((nd) => new Date(nd.created).getTime())),
  ).toISOString();
  const author_local_id: string = nodeData[0].author_uid; // take any one; again until I get the relation object
  return {
    space_id: context.spaceId,
    source_local_id: relationUid,
    author_local_id,
    created,
    last_modified,
    name: relationUid,
    is_schema: false,
    schema_represented_by_local_id: relationSchemaUid,
    local_reference_content: casting,
  };
  /* eslint-enable @typescript-eslint/naming-convention */
};

export const relatedConcepts = (concept: LocalConceptDataInput): string[] => {
  const relations = Object.values(
    concept.local_reference_content || {},
  ).flat() as string[];
  if (concept.schema_represented_by_local_id) {
    relations.push(concept.schema_represented_by_local_id);
  }
  // remove duplicates
  return [...new Set(relations)];
};

const orderConceptsRec = ({
  ordered,
  concept,
  remainder,
  processed,
}: {
  ordered: LocalConceptDataInput[];
  concept: LocalConceptDataInput;
  remainder: { [key: string]: LocalConceptDataInput };
  processed: Set<string>;
}): Set<string> => {
  // Add to processed at the start to prevent cycles
  processed.add(concept.source_local_id!);

  const relatedConceptIds = relatedConcepts(concept);
  let missing: Set<string> = new Set();
  while (relatedConceptIds.length > 0) {
    const relatedConceptId = relatedConceptIds.shift()!;
    if (processed.has(relatedConceptId)) continue;
    const relatedConcept = remainder[relatedConceptId];
    if (relatedConcept === undefined) {
      missing.add(relatedConceptId);
    } else {
      missing = new Set([
        ...missing,
        ...orderConceptsRec({
          ordered,
          concept: relatedConcept,
          remainder,
          processed,
        }),
      ]);
      delete remainder[relatedConceptId];
    }
  }
  ordered.push(concept);
  delete remainder[concept.source_local_id!];
  return missing;
};

/*
If writing a concept upsert method, you want to insure that
a node's dependencies are defined before the node itself is upserted.
The dependencies are as defined in relatedConcepts.
If you upsert in the following order: [node schemas, relation schemas, nodes, relations]
then the depencies will be implicitly respected.
(It will be tricker when we have recursive relations.)
If you are starting from a random stream of nodes, you would want to order them with this function.
It assumes all input has defined source_local_id,
and that nodes that are not in the upsert set are already in the database.
the Id of those nodes is returned and can be used to check that assumption.
We also assume that there are no dependency cycles.
 */
export const orderConceptsByDependency = (
  concepts: LocalConceptDataInput[],
): { ordered: LocalConceptDataInput[]; missing: string[] } => {
  if (concepts.length === 0) return { ordered: concepts, missing: [] };
  const conceptById = Object.fromEntries(
    concepts.map((c) => [c.source_local_id, c]),
  ) as { [key: string]: LocalConceptDataInput };
  const ordered: LocalConceptDataInput[] = [];
  let missing: Set<string> = new Set();
  const processed: Set<string> = new Set();
  while (Object.keys(conceptById).length > 0) {
    const first = Object.values(conceptById)[0];
    missing = new Set([
      ...missing,
      ...orderConceptsRec({
        ordered,
        concept: first,
        remainder: conceptById,
        processed,
      }),
    ]);
  }
  return { ordered, missing: [...missing] };
};

// the input to the upsert method would look like this:

// const idata: LocalConceptDataInput[] = [
//   { "name": "Claim", "author_local_id": "sR22zZ470dNPkIf9PpjQXXdTBjG2", "source_local_id": "a_roam_uid", "created": "2000/01/01", "last_modified": "2001/01/02", "is_schema": true },
//   { "name": "A Claim", "author_local_id": "sR22zZ470dNPkIf9PpjQXXdTBjG2", "source_local_id": "a_roam_uid2", "created": "2000/01/03", "last_modified": "2001/01/04", "is_schema": false, "schema_represented_by_local_id": "a_roam_uid" },
//   { "name": "test2", "author_local_id": "sR22zZ470dNPkIf9PpjQXXdTBjG2", "created": "2000/01/04", "last_modified": "2001/01/05", "is_schema": false, "literal_content": { "source": "a_roam_uid", "target": ["a_roam_uid", "a_roam_uid2"] }, "local_reference_content": { "source": "a_roam_uid", "target": ["a_roam_uid", "a_roam_uid2"] } }]

// const { data, error } = await supabase_client.rpc("upsert_concepts", { v_space_id: 12, data: idata });