/**
 * Universal Display Augmentation - Intelligent Computation Engine
 *
 * Leverages existing Brainy AI infrastructure for intelligent field computation:
 * - BrainyTypes for semantic type detection
 * - Neural Import patterns for field analysis
 * - JSON processing utilities for field extraction
 * - Existing NounType/VerbType taxonomy (31+40 types)
 */
import { getBrainyTypes } from '../typeMatching/brainyTypes.js';
import { getFieldPatterns, getPriorityFields } from './fieldPatterns.js';
import { prepareJsonForVectorization } from '../../utils/jsonProcessing.js';
import { NounType, VerbType } from '../../types/graphTypes.js';
/**
 * Intelligent field computation engine
 * Coordinates AI-powered analysis with fallback heuristics
 */
export class IntelligentComputationEngine {
    constructor(config) {
        this.typeMatcher = null;
        this.initialized = false;
        this.config = config;
    }
    /**
     * Initialize the computation engine with AI components
     */
    async initialize() {
        if (this.initialized)
            return;
        try {
            // 🧠 LEVERAGE YOUR EXISTING AI INFRASTRUCTURE
            this.typeMatcher = await getBrainyTypes();
            if (this.typeMatcher) {
                console.log('🎨 Display computation engine initialized with AI intelligence');
            }
            else {
                console.warn('🎨 Display computation engine running in basic mode (AI unavailable)');
            }
        }
        catch (error) {
            console.warn('🎨 AI initialization failed, using heuristic fallback:', error);
        }
        this.initialized = true;
    }
    /**
     * Compute display fields for a noun using AI-first approach
     * @param data The noun data/metadata
     * @param id Optional noun ID
     * @returns Computed display fields
     */
    async computeNounDisplay(data, id) {
        const startTime = Date.now();
        try {
            // 🟢 PRIMARY PATH: Use your existing AI intelligence
            if (this.typeMatcher) {
                return await this.computeWithAI(data, 'noun', { id });
            }
            // 🟡 FALLBACK PATH: Use heuristic patterns
            return await this.computeWithHeuristics(data, 'noun', { id });
        }
        catch (error) {
            console.warn('Display computation failed, using minimal fallback:', error);
            return this.createMinimalDisplay(data, 'noun');
        }
        finally {
            const computationTime = Date.now() - startTime;
            if (this.config.debugMode) {
                console.log(`Display computation took ${computationTime}ms`);
            }
        }
    }
    /**
     * Compute display fields for a verb using AI-first approach
     * @param verb The verb/relationship data
     * @returns Computed display fields
     */
    async computeVerbDisplay(verb) {
        const startTime = Date.now();
        try {
            // 🟢 PRIMARY PATH: Use your existing AI for verb analysis
            if (this.typeMatcher) {
                return await this.computeVerbWithAI(verb);
            }
            // 🟡 FALLBACK PATH: Use heuristic patterns for verbs
            return await this.computeWithHeuristics(verb, 'verb');
        }
        catch (error) {
            console.warn('Verb display computation failed, using minimal fallback:', error);
            return this.createMinimalDisplay(verb, 'verb');
        }
        finally {
            const computationTime = Date.now() - startTime;
            if (this.config.debugMode) {
                console.log(`Verb display computation took ${computationTime}ms`);
            }
        }
    }
    /**
     * AI-powered computation using your existing BrainyTypes
     * @param data Entity data/metadata
     * @param entityType Type of entity (noun/verb)
     * @param options Additional options
     * @returns AI-computed display fields
     */
    async computeWithAI(data, entityType, options = {}) {
        // 🧠 USE YOUR EXISTING TYPE DETECTION AI
        const typeResult = await this.typeMatcher.matchNounType(data);
        // Create computation context
        const context = {
            data,
            metadata: data,
            typeResult,
            config: this.config,
            entityType
        };
        // 🟢 INTELLIGENT FIELD EXTRACTION using your patterns + AI insights
        const displayFields = {
            title: await this.computeIntelligentTitle(context),
            description: await this.computeIntelligentDescription(context),
            type: typeResult.type,
            tags: await this.computeIntelligentTags(context),
            confidence: typeResult.confidence,
            reasoning: this.config.debugMode ? typeResult.reasoning : undefined,
            alternatives: this.config.debugMode ? typeResult.alternatives : undefined,
            computedAt: Date.now(),
            version: '1.0.0'
        };
        return displayFields;
    }
    /**
     * AI-powered verb computation using relationship analysis
     * @param verb The verb/relationship
     * @returns AI-computed display fields
     */
    async computeVerbWithAI(verb) {
        // 🧠 USE YOUR EXISTING VERB TYPE DETECTION
        const typeResult = await this.typeMatcher.matchVerbType(verb, 0.7);
        // Create verb computation context
        const context = {
            data: verb,
            metadata: verb.metadata || {},
            typeResult,
            config: this.config,
            entityType: 'verb',
            verbContext: {
                sourceId: verb.sourceId,
                targetId: verb.targetId,
                verbType: verb.type
            }
        };
        // 🟢 INTELLIGENT VERB DISPLAY COMPUTATION
        const displayFields = {
            title: await this.computeVerbTitle(context),
            description: await this.computeVerbDescription(context),
            type: typeResult.type,
            tags: await this.computeVerbTags(context),
            relationship: await this.computeHumanReadableRelationship(context),
            confidence: typeResult.confidence,
            reasoning: this.config.debugMode ? typeResult.reasoning : undefined,
            alternatives: this.config.debugMode ? typeResult.alternatives : undefined,
            computedAt: Date.now(),
            version: '1.0.0'
        };
        return displayFields;
    }
    /**
     * Heuristic computation when AI is unavailable
     * @param data Entity data
     * @param entityType Type of entity
     * @param options Additional options
     * @returns Heuristically computed display fields
     */
    async computeWithHeuristics(data, entityType, options = {}) {
        // Use basic type detection
        const detectedType = this.detectTypeHeuristically(data, entityType);
        const typeResult = {
            type: detectedType,
            confidence: 0.6, // Lower confidence for heuristics
            reasoning: 'Heuristic detection (AI unavailable)',
            alternatives: []
        };
        const context = {
            data,
            metadata: data,
            typeResult: typeResult,
            config: this.config,
            entityType
        };
        // Use pattern-based field extraction
        const patterns = getFieldPatterns(entityType, detectedType);
        return {
            title: this.extractFieldWithPatterns(data, patterns, 'title') || 'Untitled',
            description: this.extractFieldWithPatterns(data, patterns, 'description') || 'No description',
            type: detectedType,
            tags: this.extractFieldWithPatterns(data, patterns, 'tags') || [],
            confidence: typeResult.confidence,
            reasoning: this.config.debugMode ? typeResult.reasoning : undefined,
            computedAt: Date.now(),
            version: '1.0.0'
        };
    }
    /**
     * Compute intelligent title using AI insights and your field extraction
     * @param context Computation context with AI results
     * @returns Computed title
     */
    async computeIntelligentTitle(context) {
        const { data, typeResult } = context;
        // 🟢 USE TYPE-SPECIFIC LOGIC based on your NounType taxonomy
        switch (typeResult?.type) {
            case NounType.Person:
                return this.computePersonTitle(data);
            case NounType.Organization:
                return this.computeOrganizationTitle(data);
            case NounType.Project:
                return this.computeProjectTitle(data);
            case NounType.Document:
                return this.computeDocumentTitle(data);
            default:
                // 🟢 LEVERAGE YOUR JSON PROCESSING for unknown types
                return this.extractBestTitle(data, typeResult?.type);
        }
    }
    /**
     * Compute intelligent description using AI insights and context
     * @param context Computation context
     * @returns Enhanced description
     */
    async computeIntelligentDescription(context) {
        const { data, typeResult } = context;
        // 🟢 USE YOUR EXISTING JSON PROCESSING for vectorization-quality text
        const priorityFields = getPriorityFields('noun', typeResult?.type);
        const enhancedText = prepareJsonForVectorization(data, {
            priorityFields,
            includeFieldNames: false,
            maxDepth: 2
        });
        // Create context-aware description based on type
        return this.createContextAwareDescription(data, typeResult, enhancedText);
    }
    /**
     * Compute intelligent tags using type analysis
     * @param context Computation context
     * @returns Generated tags array
     */
    async computeIntelligentTags(context) {
        const { data, typeResult } = context;
        const tags = [];
        // Add type-based tag
        if (typeResult?.type) {
            tags.push(typeResult.type.toLowerCase());
        }
        // Extract explicit tags from data
        const explicitTags = this.extractExplicitTags(data);
        tags.push(...explicitTags);
        // Add semantic tags based on AI analysis
        if (typeResult && this.typeMatcher) {
            const semanticTags = this.generateSemanticTags(data, typeResult);
            tags.push(...semanticTags);
        }
        // Remove duplicates and return
        return [...new Set(tags.filter(Boolean))];
    }
    /**
     * Compute verb title (relationship summary)
     * @param context Verb computation context
     * @returns Verb title
     */
    async computeVerbTitle(context) {
        const { verbContext, typeResult } = context;
        if (!verbContext)
            return 'Relationship';
        const { sourceId, targetId } = verbContext;
        const relationshipType = typeResult?.type || 'RelatedTo';
        // Try to get readable names for source and target
        // This could be enhanced to actually resolve the entities
        return `${sourceId} ${this.getReadableVerbPhrase(relationshipType)} ${targetId}`;
    }
    /**
     * Create minimal display for error cases
     * @param data Entity data
     * @param entityType Entity type
     * @returns Minimal display fields
     */
    createMinimalDisplay(data, entityType) {
        return {
            title: data.name || data.title || data.id || 'Untitled',
            description: data.description || data.summary || 'No description available',
            type: entityType === 'noun' ? 'Item' : 'RelatedTo',
            tags: [],
            confidence: 0.1, // Very low confidence for fallback
            computedAt: Date.now(),
            version: '1.0.0'
        };
    }
    // Helper methods for specific noun types
    computePersonTitle(data) {
        if (data.firstName && data.lastName) {
            return `${data.firstName} ${data.lastName}`.trim();
        }
        return data.name || data.fullName || data.displayName || data.firstName || data.lastName || 'Person';
    }
    computeOrganizationTitle(data) {
        return data.name || data.companyName || data.organizationName || data.title || 'Organization';
    }
    computeProjectTitle(data) {
        return data.name || data.projectName || data.title || data.projectTitle || 'Project';
    }
    computeDocumentTitle(data) {
        return data.title || data.filename || data.name || data.subject || 'Document';
    }
    extractBestTitle(data, type) {
        const titleFields = ['name', 'title', 'displayName', 'label', 'subject', 'heading'];
        for (const field of titleFields) {
            if (data[field])
                return String(data[field]);
        }
        return data.id || Object.keys(data)[0] || 'Untitled';
    }
    createContextAwareDescription(data, typeResult, enhancedText) {
        // Start with basic description fields
        const basicDesc = data.description || data.summary || data.about || data.details;
        if (basicDesc)
            return String(basicDesc);
        // Use enhanced text from JSON processing
        if (enhancedText && enhancedText.length > 10) {
            return enhancedText.substring(0, 200) + (enhancedText.length > 200 ? '...' : '');
        }
        // Generate from available fields
        const parts = [];
        if (data.role)
            parts.push(data.role);
        if (data.company)
            parts.push(`at ${data.company}`);
        if (data.location)
            parts.push(`in ${data.location}`);
        return parts.length > 0 ? parts.join(' ') : 'No description available';
    }
    extractExplicitTags(data) {
        const tagFields = ['tags', 'keywords', 'labels', 'categories', 'topics'];
        for (const field of tagFields) {
            if (data[field]) {
                if (Array.isArray(data[field])) {
                    return data[field].map(String).filter(Boolean);
                }
                if (typeof data[field] === 'string') {
                    return data[field].split(/[,;]\s*|\s+/).filter(Boolean);
                }
            }
        }
        return [];
    }
    generateSemanticTags(data, typeResult) {
        const tags = [];
        // Add confidence-based tags
        if (typeResult.confidence > 0.9)
            tags.push('verified');
        else if (typeResult.confidence < 0.7)
            tags.push('uncertain');
        // Add type-specific semantic tags
        if (data.status)
            tags.push(String(data.status).toLowerCase());
        if (data.priority)
            tags.push(String(data.priority).toLowerCase());
        if (data.category)
            tags.push(String(data.category).toLowerCase());
        return tags;
    }
    getReadableVerbPhrase(verbType) {
        const verbPhrases = {
            [VerbType.WorksWith]: 'works with',
            [VerbType.MemberOf]: 'is member of',
            [VerbType.ReportsTo]: 'reports to',
            [VerbType.CreatedBy]: 'created by',
            [VerbType.Owns]: 'owns',
            [VerbType.LocatedAt]: 'located at',
            [VerbType.Likes]: 'likes',
            [VerbType.Follows]: 'follows',
            [VerbType.Supervises]: 'supervises'
        };
        return verbPhrases[verbType] || 'related to';
    }
    async computeVerbDescription(context) {
        const { data, verbContext, typeResult } = context;
        if (data.description)
            return String(data.description);
        // Generate contextual description for relationship
        if (verbContext && typeResult) {
            const parts = [];
            const relationshipPhrase = this.getReadableVerbPhrase(typeResult.type);
            if (data.role)
                parts.push(`Role: ${data.role}`);
            if (data.startDate)
                parts.push(`Since: ${new Date(data.startDate).toLocaleDateString()}`);
            if (data.department)
                parts.push(`Department: ${data.department}`);
            return parts.length > 0
                ? `${relationshipPhrase} - ${parts.join(', ')}`
                : `${relationshipPhrase} relationship`;
        }
        return 'Relationship';
    }
    async computeVerbTags(context) {
        const { data, typeResult } = context;
        const tags = ['relationship'];
        if (typeResult?.type) {
            tags.push(typeResult.type.toLowerCase());
        }
        // Add relationship-specific tags
        if (data.status)
            tags.push(String(data.status).toLowerCase());
        if (data.type)
            tags.push(String(data.type).toLowerCase());
        return [...new Set(tags)];
    }
    async computeHumanReadableRelationship(context) {
        const { verbContext, typeResult } = context;
        if (!verbContext || !typeResult)
            return 'Related';
        const { sourceId, targetId } = verbContext;
        const phrase = this.getReadableVerbPhrase(typeResult.type);
        return `${sourceId} ${phrase} ${targetId}`;
    }
    detectTypeHeuristically(data, entityType) {
        if (entityType === 'verb')
            return VerbType.RelatedTo;
        // Basic heuristics for noun types
        if (data.firstName || data.lastName || data.email)
            return NounType.Person;
        if (data.companyName || data.organization)
            return NounType.Organization;
        if (data.filename || data.fileType)
            return NounType.Document;
        if (data.projectName || data.initiative)
            return NounType.Project;
        if (data.taskName || data.todo)
            return NounType.Task;
        if (data.startDate || data.endDate)
            return NounType.Event;
        return 'Item'; // Generic fallback
    }
    extractFieldWithPatterns(data, patterns, fieldType) {
        const relevantPatterns = patterns.filter(p => p.displayField === fieldType);
        for (const pattern of relevantPatterns) {
            for (const field of pattern.fields) {
                if (data[field]) {
                    return pattern.transform ? pattern.transform(data[field], { data, config: this.config }) : data[field];
                }
            }
        }
        return null;
    }
    /**
     * Shutdown the computation engine
     */
    async shutdown() {
        // Cleanup if needed
        this.typeMatcher = null;
        this.initialized = false;
    }
}
//# sourceMappingURL=intelligentComputation.js.map