frontend/src/lib/schema-detection.ts

/**
 * Schema Detection Utility for Knowledge Graph Data
 *
 * Detects whether knowledge graph data uses reference-based or direct-based schema
 * and provides capability information for conditional feature rendering.
 */

export interface SchemaCapabilities {
  supportsLineReferences: boolean;
  supportsFailures: boolean;
  supportsImportanceLevels: boolean;
  supportsInteractionPrompts: boolean;
}

/**
 * Detect schema type from knowledge graph data structure
 */
export function detectSchemaType(
  data: any
): "reference_based" | "direct_based" {
  if (!data) {
    console.warn(
      "Schema detection: No data provided, defaulting to direct_based"
    );
    return "direct_based";
  }

  try {
    // Check entities for reference-based indicators
    const hasEntityRefs = data.entities?.some(
      (entity: any) =>
        Array.isArray(entity.raw_prompt_ref) && entity.raw_prompt_ref.length > 0
    );

    // Check relations for reference-based indicators
    const hasRelationRefs = data.relations?.some(
      (relation: any) =>
        Array.isArray(relation.interaction_prompt_ref) &&
        relation.interaction_prompt_ref.length > 0
    );

    // Check for failures array (reference-based only)
    const hasFailures =
      Array.isArray(data.failures) && data.failures.length > 0;

    // Check for importance levels (more common in reference-based)
    const hasImportanceLevels = data.entities?.some(
      (entity: any) =>
        entity.importance &&
        ["HIGH", "MEDIUM", "LOW"].includes(entity.importance)
    );

    const isReferenceBased =
      hasEntityRefs || hasRelationRefs || hasFailures || hasImportanceLevels;

    console.log("Schema detection results:", {
      hasEntityRefs,
      hasRelationRefs,
      hasFailures,
      hasImportanceLevels,
      schemaType: isReferenceBased ? "reference_based" : "direct_based",
    });

    return isReferenceBased ? "reference_based" : "direct_based";
  } catch (error) {
    console.warn("Schema detection failed, defaulting to direct_based:", error);
    return "direct_based";
  }
}

/**
 * Check if data has reference-based features
 */
export function hasReferenceBasedFeatures(data: any): boolean {
  return detectSchemaType(data) === "reference_based";
}

/**
 * Get schema capabilities based on schema type
 */
export function getSchemaCapabilities(
  schemaType: "reference_based" | "direct_based"
): SchemaCapabilities {
  if (schemaType === "reference_based") {
    return {
      supportsLineReferences: true,
      supportsFailures: true,
      supportsImportanceLevels: true,
      supportsInteractionPrompts: true,
    };
  } else {
    return {
      supportsLineReferences: false,
      supportsFailures: false,
      supportsImportanceLevels: false,
      supportsInteractionPrompts: false,
    };
  }
}