5. Object Mapping

// Manual mapping - tedious and error-prone
var platformDto = new PlatformReadDto
{
    Id = platform.Id,
    PlatformName = platform.PlatformName,
    CommandCount = platform.Commands.Count,
    CreatedBy = platform.CreatedBy
};
// Multiply this by every endpoint...

var platformDto = _mapper.Map<PlatformReadDto>(platform);

dotnet add package AutoMapper.Extensions.Microsoft.DependencyInjection

// Program.csbuilder.Services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());// This scans all assemblies for classes inheriting from Profile// and registers them automatically

using AutoMapper;
using CommandAPI.Models;
using CommandAPI.Dtos;

namespace CommandAPI.Profiles;

public class PlatformsProfile : Profile
{
    public PlatformsProfile()
    {
        // Simple mapping (properties match by name)
        CreateMap<Platform, PlatformReadDto>()
            .ForMember(dest => dest.CommandCount,
                opt => opt.MapFrom(src => src.Commands.Count));
        
        // Reverse mapping for updates
        CreateMap<PlatformMutateDto, Platform>();
        
        // Bidirectional
        CreateMap<Platform, PlatformMutateDto>().ReverseMap();
    }
}

public class CommandsProfile : Profile
{
    public CommandsProfile()
    {
        // Model -> Read DTO
        CreateMap<Command, CommandReadDto>()
            .ForMember(dest => dest.PlatformName,
                opt => opt.MapFrom(src => src.Platform.PlatformName))
            .ForMember(dest => dest.CreatedDate,
                opt => opt.MapFrom(src => src.CreatedAt.ToString("yyyy-MM-dd")));
        
        // Mutate DTO -> Model
        CreateMap<CommandMutateDto, Command>()
            .ForMember(dest => dest.Id, opt => opt.Ignore())  // Never map ID on create
            .ForMember(dest => dest.Platform, opt => opt.Ignore())  // Will be loaded separately
            .ForMember(dest => dest.CreatedAt, opt => opt.Ignore());  // Set by system
        
        // For PATCH operations
        CreateMap<Command, CommandMutateDto>();
    }
}

public class PaginationProfile : Profile
{
    public PaginationProfile()
    {
        // Generic pagination mapping
        CreateMap(typeof(PaginatedList<>), typeof(PaginatedList<>));
    }
}

// Current code has this - it's okay but could be more specific
public class GenericProfile : Profile
{
    public GenericProfile()
    {
        CreateMap(typeof(PaginatedList<>), typeof(PaginatedList<>));
    }
}

// Better: PaginationProfile.cs
public class PaginationProfile : Profile
{
    public PaginationProfile()
    {
        // Generic type mapping
        CreateMap(typeof(PaginatedList<>), typeof(PaginatedList<>));
        
        // Specific mappings if needed
        CreateMap<PaginatedList<Platform>, PaginatedList<PlatformReadDto>>();
        CreateMap<PaginatedList<Command>, PaginatedList<CommandReadDto>>();
    }
}

// AutoMapper automatically maps properties with:
// - Same name (case-insensitive)
// - Source property to destination property
// - Flattening: Source.Property.SubProperty -> Destination.PropertySubProperty

public class Command
{
    public int Id { get; set; }
    public string HowTo { get; set; }
    public string CommandLine { get; set; }
    public Platform Platform { get; set; }
}

public class CommandReadDto
{
    public int Id { get; set; }          // ✅ Auto-mapped
    public string HowTo { get; set; }     // ✅ Auto-mapped
    public string CommandLine { get; set; } // ✅ Auto-mapped
    public string PlatformName { get; set; } // ❌ Requires custom mapping
}

// Custom mapping needed:
CreateMap<Command, CommandReadDto>()
    .ForMember(dest => dest.PlatformName,
        opt => opt.MapFrom(src => src.Platform.PlatformName));

public class CommandsProfile : Profile
{
    public CommandsProfile()
    {
        CreateMap<Command, CommandReadDto>()
            // Map from nested property
            .ForMember(dest => dest.PlatformName,
                opt => opt.MapFrom(src => src.Platform.PlatformName))
            
            // Conditional mapping
            .ForMember(dest => dest.IsRecent,
                opt => opt.MapFrom(src => src.CreatedAt > DateTime.UtcNow.AddDays(-7)))
            
            // Custom resolver
            .ForMember(dest => dest.DisplayText,
                opt => opt.MapFrom<CommandDisplayTextResolver>())
            
            // Ignore property
            .ForMember(dest => dest.InternalField,
                opt => opt.Ignore())
            
            // Null substitution
            .ForMember(dest => dest.Description,
                opt => opt.NullSubstitute("No description provided"))
            
            // Value transformation
            .ForMember(dest => dest.CommandLine,
                opt => opt.MapFrom(src => src.CommandLine.Trim()))
            
            // After map action
            .AfterMap((src, dest) =>
            {
                // Custom logic after mapping
                dest.Popularity = CalculatePopularity(src);
            });
    }
}

// Custom resolver
public class CommandDisplayTextResolver : IValueResolver<Command, CommandReadDto, string>
{
    public string Resolve(Command source, CommandReadDto destination,
        string destMember, ResolutionContext context)
    {
        return $"{source.Platform.PlatformName}: {source.HowTo}";
    }
}

// Create comprehensive mapping tests
using AutoMapper;
using Xunit;

namespace CommandAPI.Tests.Profiles;

public class MappingProfileTests
{
    private readonly IMapper _mapper;
    
    public MappingProfileTests()
    {
        var configuration = new MapperConfiguration(cfg =>
        {
            cfg.AddMaps(typeof(Program).Assembly);
        });
        
        _mapper = configuration.CreateMapper();
    }
    
    [Fact]
    public void AutoMapper_Configuration_IsValid()
    {
        // This will throw if any mappings are invalid
        _mapper.ConfigurationProvider.AssertConfigurationIsValid();
    }
    
    [Fact]
    public void Platform_To_PlatformReadDto_Maps_Correctly()
    {
        // Arrange
        var platform = new Platform
        {
            Id = 1,
            PlatformName = "Docker",
            Commands = new List<Command>
            {
                new Command { /* ... */ },
                new Command { /* ... */ }
            }
        };
        
        // Act
        var dto = _mapper.Map<PlatformReadDto>(platform);
        
        // Assert
        Assert.Equal(platform.Id, dto.Id);
        Assert.Equal(platform.PlatformName, dto.PlatformName);
        Assert.Equal(2, dto.CommandCount);
    }
    
    [Fact]
    public void Command_To_CommandReadDto_Includes_PlatformName()
    {
        // Arrange
        var command = new Command
        {
            Id = 1,
            HowTo = "Run container",
            CommandLine = "docker run",
            Platform = new Platform { PlatformName = "Docker" }
        };
        
        // Act
        var dto = _mapper.Map<CommandReadDto>(command);
        
        // Assert
        Assert.Equal("Docker", dto.PlatformName);
    }
}

[Route("api/[controller]")]
[ApiController]
public class PlatformsController : ControllerBase
{
    private readonly ICommandRepository _repository;
    private readonly IMapper _mapper;
    private readonly ILogger<PlatformsController> _logger;

    public PlatformsController(
        ICommandRepository repository,
        IMapper mapper,
        ILogger<PlatformsController> logger)
    {
        _repository = repository;
        _mapper = mapper;
        _logger = logger;
    }

    [HttpGet]
    public async Task<ActionResult<PaginatedList<PlatformReadDto>>> GetPlatforms(
        int pageIndex = 1, int pageSize = 10)
    {
        var platforms = await _repository.GetPlatformsAsync(pageIndex, pageSize);
        
        // Map entire paginated list
        var platformDtos = _mapper.Map<PaginatedList<PlatformReadDto>>(platforms);
        
        return Ok(platformDtos);
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<PlatformReadDto>> GetPlatformById(int id)
    {
        var platform = await _repository.GetPlatformByIdAsync(id);
        
        if (platform == null)
            return NotFound();
        
        // Map single entity
        return Ok(_mapper.Map<PlatformReadDto>(platform));
    }

    [HttpPost]
    public async Task<ActionResult<PlatformReadDto>> CreatePlatform(
        PlatformMutateDto platformDto)
    {
        // Map DTO to entity
        var platform = _mapper.Map<Platform>(platformDto);
        platform.CreatedBy = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
        
        await _repository.CreatePlatformAsync(platform);
        await _repository.SaveChangesAsync();
        
        // Map entity back to read DTO
        var readDto = _mapper.Map<PlatformReadDto>(platform);
        
        return CreatedAtRoute(
            nameof(GetPlatformById),
            new { id = readDto.Id },
            readDto);
    }

    [HttpPut("{id}")]
    public async Task<ActionResult> UpdatePlatform(
        int id, PlatformMutateDto platformDto)
    {
        var platform = await _repository.GetPlatformByIdAsync(id);
        
        if (platform == null)
            return NotFound();
        
        // Map DTO properties to existing entity (preserves Id, CreatedAt, etc.)
        _mapper.Map(platformDto, platform);
        
        await _repository.UpdatePlatformAsync(platform);
        await _repository.SaveChangesAsync();
        
        return NoContent();
    }
}

// ✅ Good: Map collections efficiently
var dtos = _mapper.Map<List<PlatformReadDto>>(platforms);

// ❌ Bad: Mapping in a loop
var dtos = new List<PlatformReadDto>();
foreach (var platform in platforms)
{
    dtos.Add(_mapper.Map<PlatformReadDto>(platform));
}

// ✅ Good: Use ProjectTo for database queries (reduces data transfer)
var platforms = await _context.Platforms
    .ProjectTo<PlatformReadDto>(_mapper.ConfigurationProvider)
    .ToListAsync();

// This translates mapping to SQL SELECT - only fetches needed columns

// ❌ Bad: Fetch everything then map
var platforms = await _context.Platforms.ToListAsync();
var dtos = _mapper.Map<List<PlatformReadDto>>(platforms);