Mappers¶

public interface IRdfEntityMapper<TRdfDefinition, TEntity>
    where TRdfDefinition : class, IRdfDefinition
    where TEntity : class, IEntity
{
    /// <summary>
    /// Returns true if this mapper can handle the given RDF class (type) of this resource.
    /// Matches both unqualified (e.g., "Equipment") and qualified (e.g., "cim:Equipment") names.
    /// </summary>
    bool CanMap(string className);

    /// <summary>
    /// Creates a domain entity from the given RDF definition.
    /// Returns null if the definition does not have required data.
    /// </summary>
    TEntity? Map(TRdfDefinition definition);

    /// <summary>
    /// Gets a value indicating whether this mapper supports reverse mapping (entity to RDF definition).
    /// </summary>
    bool CanUnmap => false;

    /// <summary>
    /// Creates an RDF definition from the given domain entity.
    /// Returns null if reverse mapping is not supported or the entity cannot be converted.
    /// </summary>
    TRdfDefinition? Unmap(TEntity entity) => null;
}

public interface IRdfEntityMapper<TRdfDefinition, TEntity, TKey> : IRdfEntityMapper<TRdfDefinition, TEntity>
    where TRdfDefinition : class, IRdfDefinition
    where TEntity : class, IEntity<TKey>
{
}

public interface IRdfEntityMapperFactory
{
    /// <summary>
    /// Gets the RDF entity mapper for the specified entity type.
    /// </summary>
    IRdfEntityMapper<TRdfDefinition, TEntity> GetMapper<TRdfDefinition, TEntity>()
        where TRdfDefinition : class, IRdfDefinition
        where TEntity : class, IEntity;

    /// <summary>
    /// Gets the RDF entity mapper for the specified entity type and key type.
    /// </summary>
    IRdfEntityMapper<TRdfDefinition, TEntity, TKey> GetMapper<TRdfDefinition, TEntity, TKey>()
        where TRdfDefinition : class, IRdfDefinition
        where TEntity : class, IEntity<TKey>;
}

public class MyEntityMapper : IRdfEntityMapper<MyRdfDefinition, MyEntity, Guid>
{
    private readonly IRdfIdentifierParser _identifierParser;
    private readonly IRdfValueParser _valueParser;

    public MyEntityMapper(IRdfIdentifierParser identifierParser, IRdfValueParser valueParser)
    {
        _identifierParser = identifierParser;
        _valueParser = valueParser;
    }

    #region Forward Mapping (RDF → Entity)

    public bool CanMap(string className)
    {
        if (string.IsNullOrWhiteSpace(className))
            return false;

        var name = className.Trim();
        return name.Equals("MyEntity", StringComparison.Ordinal)
            || name.EndsWith(":MyEntity", StringComparison.Ordinal);
    }

    public MyEntity? Map(MyRdfDefinition definition)
    {
        if (definition == null)
            return null;

        // 1. Extract and validate identity
        if (!_identifierParser.TryParseGuid(definition.Id, out var entityId))
            return null;

        // 2. Extract properties from definition
        var name = GetPropertyValue(definition, "name") ?? $"MyEntity:{entityId:D}";

        // 3. Parse typed values
        var valueStr = GetPropertyValue(definition, "value");
        if (!_valueParser.TryParseFloat(valueStr, out var value))
            return null;

        // 4. Construct domain entity with validated data
        return new MyEntity(entityId, name, value);
    }

    private string? GetPropertyValue(MyRdfDefinition definition, string propertyName)
    {
        // Implementation depends on your RdfDefinition structure
        return definition.Properties
            .FirstOrDefault(p => p.Name.EndsWith(propertyName))
            ?.ToString();
    }

    #endregion

    #region Reverse Mapping (Entity → RDF)

    public bool CanUnmap => true;

    public MyRdfDefinition? Unmap(MyEntity entity)
    {
        if (entity == null)
            return null;

        // Create definition with ID and class name
        var definition = new MyRdfDefinition(
            id: entity.Id.ToString("D"),
            className: "ns:MyEntity"
        );

        // Add properties
        definition.Properties.Add(new MyLiteralProperty("ns:name", entity.Name));
        definition.Properties.Add(new MyLiteralProperty("ns:value", entity.Value.ToString()));

        return definition;
    }

    #endregion
}

public class RdfEntityMapperFactory : IRdfEntityMapperFactory, ITransientDependency
{
    private readonly IServiceProvider _serviceProvider;
    private readonly Lazy<Dictionary<Type, Type>> _mapperTypes;

    public RdfEntityMapperFactory(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
        _mapperTypes = new Lazy<Dictionary<Type, Type>>(DiscoverMapperTypes);
    }

    private Dictionary<Type, Type> DiscoverMapperTypes()
    {
        var result = new Dictionary<Type, Type>();

        var assemblyFinder = _serviceProvider.GetService<IAssemblyFinder>();
        if (assemblyFinder == null)
            return result;

        foreach (var assembly in assemblyFinder.Assemblies)
        {
            Type[] types;
            try { types = assembly.GetTypes(); }
            catch { continue; }

            foreach (var type in types)
            {
                if (type.IsAbstract || type.IsInterface)
                    continue;

                var interfaces = type.GetInterfaces()
                    .Where(i => i.IsGenericType)
                    .Where(i =>
                    {
                        var def = i.GetGenericTypeDefinition();
                        return def == typeof(IRdfEntityMapper<,>) 
                            || def == typeof(IRdfEntityMapper<,,>);
                    });

                foreach (var iface in interfaces)
                {
                    result[iface] = type;
                }
            }
        }

        return result;
    }

    public IRdfEntityMapper<TRdfDefinition, TEntity> GetMapper<TRdfDefinition, TEntity>()
        where TRdfDefinition : class, IRdfDefinition
        where TEntity : class, IEntity
    {
        var targetInterface = typeof(IRdfEntityMapper<TRdfDefinition, TEntity>);

        if (_mapperTypes.Value.TryGetValue(targetInterface, out var mapperType))
        {
            return (IRdfEntityMapper<TRdfDefinition, TEntity>)_serviceProvider.GetRequiredService(mapperType);
        }

        var mapper = _serviceProvider.GetService<IRdfEntityMapper<TRdfDefinition, TEntity>>();
        if (mapper != null)
            return mapper;

        throw new InvalidOperationException(
            $"No IRdfEntityMapper<{typeof(TRdfDefinition).Name}, {typeof(TEntity).Name}> implementation was found or registered.");
    }

    public IRdfEntityMapper<TRdfDefinition, TEntity, TKey> GetMapper<TRdfDefinition, TEntity, TKey>()
        where TRdfDefinition : class, IRdfDefinition
        where TEntity : class, IEntity<TKey>
    {
        var targetInterface = typeof(IRdfEntityMapper<TRdfDefinition, TEntity, TKey>);

        if (_mapperTypes.Value.TryGetValue(targetInterface, out var mapperType))
        {
            return (IRdfEntityMapper<TRdfDefinition, TEntity, TKey>)_serviceProvider.GetRequiredService(mapperType);
        }

        var mapper = _serviceProvider.GetService<IRdfEntityMapper<TRdfDefinition, TEntity, TKey>>();
        if (mapper != null)
            return mapper;

        // Fallback: Try non-keyed mapper if it also implements keyed interface
        var nonKeyedMapper = _serviceProvider.GetService<IRdfEntityMapper<TRdfDefinition, TEntity>>();
        if (nonKeyedMapper is IRdfEntityMapper<TRdfDefinition, TEntity, TKey> keyedMapper)
            return keyedMapper;

        throw new InvalidOperationException(
            $"No IRdfEntityMapper<{typeof(TRdfDefinition).Name}, {typeof(TEntity).Name}, {typeof(TKey).Name}> implementation was found or registered.");
    }
}

public class ReadOnlyEntityMapper : IRdfEntityMapper<MyRdfDefinition, ReadOnlyEntity, Guid>
{
    public bool CanMap(string className) => className.EndsWith(":ReadOnlyEntity");

    public ReadOnlyEntity? Map(MyRdfDefinition definition)
    {
        // Forward mapping implementation
    }

    // CanUnmap defaults to false (from interface default)
    // Unmap defaults to returning null (from interface default)
}

public class CrudEntityMapper : IRdfEntityMapper<MyRdfDefinition, CrudEntity, Guid>
{
    // Forward mapping
    public bool CanMap(string className) => className.EndsWith(":CrudEntity");
    public CrudEntity? Map(MyRdfDefinition definition) { /* ... */ }

    // Reverse mapping - override defaults
    public bool CanUnmap => true;
    public MyRdfDefinition? Unmap(CrudEntity entity)
    {
        if (entity == null) return null;

        var definition = new MyRdfDefinition(
            id: entity.Id.ToString("D"),
            className: "ns:CrudEntity");
        // Add properties...
        return definition;
    }
}

// Repository checks mapper capability before write operations
public virtual TEntity Upsert(TEntity entity)
{
    if (!Mapper.CanUnmap)
        throw new NotSupportedException(
            $"Mapper for {typeof(TEntity).Name} does not support reverse mapping.");

    var definition = Mapper.Unmap(entity);
    if (definition == null)
        throw new InvalidOperationException("Mapper returned null.");

    // Perform upsert using Writer
    if (Writer.Exists(graph, definition.Id))
        Writer.Update(graph, definition);
    else
        Writer.Insert(graph, definition);

    return entity;
}

// RdfEntityMapperFactory discovers mappers automatically
// because they implement IRdfEntityMapper<TRdfDefinition, TEntity> 
// or IRdfEntityMapper<TRdfDefinition, TEntity, TKey>

// Get repository with graph context
var repository = serviceProvider.GetRequiredService<IRdfGraphRepository<MyEntity, Guid>>();

// Find by ID - uses Map() internally
var entity = repository.Find(Guid.Parse("c24a1f3e-..."));

// Get list - uses Map() for each definition
var entities = repository.GetList();

// Create new entity
var newEntity = new MyEntity(Guid.NewGuid(), "Name", 42.0f);

// Insert uses Unmap() internally
repository.Insert(newEntity);

// Update uses Unmap() internally  
entity.Name = "Updated Name";
repository.Update(entity);

// Upsert uses Unmap() internally
repository.Upsert(newEntity);

var mapper = serviceProvider.GetRequiredService<IRdfEntityMapper<MyRdfDefinition, MyEntity, Guid>>();

// Forward mapping (RDF → Entity)
var entity = mapper.Map(rdfDefinition);

// Reverse mapping (Entity → RDF)
if (mapper.CanUnmap)
{
    var definition = mapper.Unmap(entity);
    // definition can be used with IRdfInstanceWriter
}