Digital Twins

type DigitalTwin struct {
    ID          string
    ProjectID   string
    OntologyID  string              // Blueprint for entity types
    Name        string
    Description string
    Status      string              // active, syncing, error
    Config      *DigitalTwinConfig
    Metadata    map[string]interface{}
    CreatedAt   time.Time
    UpdatedAt   time.Time
    LastSyncAt  *time.Time
}

type DigitalTwinConfig struct {
    StorageIDs         []string // CIR data sources
    CacheTTL           int      // Cache TTL in seconds
    AutoSync           bool     // Auto-sync on storage changes
    SyncInterval       int      // Sync interval in seconds
    EnablePredictions  bool     // ML predictions enabled
    PredictionCacheTTL int      // Prediction cache TTL
    IndexingStrategy   string   // "lazy" or "eager"
}

func (s *Service) syncFromStorage(twin *models.DigitalTwin, ont *models.Ontology, storageID string) error {
    // Retrieve CIR data
    cirs, err := s.storageService.Retrieve(storageID, &models.CIRQuery{})
    
    // Pre-load existing entities per type
    typeIndex := make(map[string]map[string]*models.Entity)
    
    for _, cir := range cirs {
        entityType := inferEntityTypeFromCIR(cir, classNames)
        attrs := extractAttributes(cir)
        
        // Attempt entity resolution by matching key fields
        keyFields := detectKeyFields(attrs)
        var resolved *models.Entity
        for _, kf := range keyFields {
            kv := keyValue(attrs[kf])
            if existing, ok := typeIndex[entityType][kf+":"+kv]; ok {
                resolved = existing
                break
            }
        }
        
        if resolved != nil {
            // Merge: add new attributes without overwriting
            for k, v := range attrs {
                if _, exists := resolved.Attributes[k]; !exists {
                    resolved.Attributes[k] = v
                }
            }
            resolved.UpdatedAt = time.Now()
            s.store.SaveEntity(resolved)
        } else {
            // Create new entity
            entity := &models.Entity{
                ID:            uuid.New().String(),
                DigitalTwinID: twin.ID,
                Type:          entityType,
                Attributes:    attrs,
                CreatedAt:     time.Now(),
            }
            s.store.SaveEntity(entity)
        }
    }
    
    return nil
}

func (s *Service) wireRelationships(twinID string) error {
    allEntities, _ := s.store.ListEntitiesByDigitalTwin(twinID)
    
    // Group by type
    byType := make(map[string][]*models.Entity)
    for _, e := range allEntities {
        byType[e.Type] = append(byType[e.Type], e)
    }
    
    // For each pair of entity types
    for i, typeA := range types {
        for j, typeB := range types[i+1:] {
            // Find common key fields
            sharedKeys := commonKeyFieldNames(byType[typeA], byType[typeB])
            
            // Build index for type B
            bIndex := make(map[string]map[string]*models.Entity)
            for _, e := range byType[typeB] {
                for _, kf := range sharedKeys {
                    kv := keyValue(e.Attributes[kf])
                    bIndex[kf][kv] = e
                }
            }
            
            // Match entities from type A
            for _, eA := range byType[typeA] {
                for _, kf := range sharedKeys {
                    kv := keyValue(eA.Attributes[kf])
                    if eB, ok := bIndex[kf][kv]; ok {
                        // Create bidirectional relationship
                        relType := "relatedBy" + toCamelCase(kf)
                        eA.Relationships = append(eA.Relationships, &models.EntityRelationship{
                            Type:       relType,
                            TargetID:   eB.ID,
                            TargetType: typeB,
                        })
                        eB.Relationships = append(eB.Relationships, &models.EntityRelationship{
                            Type:       relType,
                            TargetID:   eA.ID,
                            TargetType: typeA,
                        })
                    }
                }
            }
        }
    }
    
    return nil
}

func (s *Service) enrichPredictionInput(req *models.PredictionRequest) error {
    entity, _ := s.store.GetEntity(req.EntityID)
    
    // Auto-populate from entity attributes
    if len(req.Input) == 0 {
        req.Input = make(map[string]interface{})
        for k, v := range entity.Attributes {
            req.Input[k] = v
        }
    }
    
    // Merge related entity attributes with type prefix
    for _, rel := range entity.Relationships {
        related, _ := s.store.GetEntity(rel.TargetID)
        prefix := strings.ToLower(rel.TargetType) + "."
        for k, v := range related.Attributes {
            key := prefix + k
            if _, exists := req.Input[key]; !exists {
                req.Input[key] = v
            }
        }
    }
    
    return nil
}