ShopSolution-backend/Webshop.Application/Services/Admin/AdminAddressService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Webshop.Application;
using Webshop.Application.DTOs.Customers;
using Webshop.Application.Services.Admin.Interfaces;
using Webshop.Domain.Entities;
using Webshop.Domain.Interfaces;

namespace Webshop.Application.Services.Admin
{
    public class AdminAddressService : IAdminAddressService
    {
        private readonly IAddressRepository _addressRepository;

        public AdminAddressService(IAddressRepository addressRepository)
        {
            _addressRepository = addressRepository;
        }

        public async Task<ServiceResult<IEnumerable<AddressDto>>> GetAllUnlinkedAddressesAsync()
        {
            var addresses = await _addressRepository.GetAllAsync();
            // Filtere nur die Adressen, die KEINEM Kunden zugeordnet sind
            var unlinkedAddresses = addresses.Where(a => a.CustomerId == null);
            return ServiceResult.Ok(unlinkedAddresses.Select(MapToDto));
        }

        public async Task<ServiceResult<AddressDto>> GetAddressByIdAsync(Guid addressId)
        {
            var address = await _addressRepository.GetByIdAsync(addressId);
            if (address == null)
            {
                return ServiceResult.Fail<AddressDto>(ServiceResultType.NotFound, $"Adresse mit ID '{addressId}' nicht gefunden.");
            }
            // Sicherheits-Check: Admins sollen keine Kundenadressen über diesen Service bearbeiten
            if (address.CustomerId != null)
            {
                return ServiceResult.Fail<AddressDto>(ServiceResultType.Forbidden, "Diese Adresse ist einem Kunden zugeordnet und kann hier nicht verwaltet werden.");
            }
            return ServiceResult.Ok(MapToDto(address));
        }

        public async Task<ServiceResult<AddressDto>> CreateAddressAsync(CreateAddressDto addressDto)
        {
            var newAddress = new Address
            {
                // WICHTIG: CustomerId wird bewusst auf null gesetzt
                CustomerId = null,
                // Für generische Adressen brauchen wir FirstName/LastName im Create-DTO
                FirstName = addressDto.FirstName, // Annahme: DTO wird erweitert
                LastName = addressDto.LastName,   // Annahme: DTO wird erweitert
                Street = addressDto.Street,
                HouseNumber = addressDto.HouseNumber,
                City = addressDto.City,
                PostalCode = addressDto.PostalCode,
                Country = addressDto.Country,
                Type = addressDto.Type
            };

            await _addressRepository.AddAsync(newAddress);
            return ServiceResult.Ok(MapToDto(newAddress));
        }

        public async Task<ServiceResult> UpdateAddressAsync(UpdateAddressDto addressDto)
        {
            var address = await _addressRepository.GetByIdAsync(addressDto.Id);
            if (address == null) return ServiceResult.Fail(ServiceResultType.NotFound, "Adresse nicht gefunden.");

            // Sicherheits-Check
            if (address.CustomerId != null)
            {
                return ServiceResult.Fail(ServiceResultType.Forbidden, "Kundenadressen können hier nicht bearbeitet werden.");
            }

            address.FirstName = addressDto.FirstName;
            address.LastName = addressDto.LastName;
            address.Street = addressDto.Street;
            // ... (restliches Mapping)
            await _addressRepository.UpdateAsync(address);
            return ServiceResult.Ok();
        }

        public async Task<ServiceResult> DeleteAddressAsync(Guid addressId)
        {
            var address = await _addressRepository.GetByIdAsync(addressId);
            if (address == null) return ServiceResult.Fail(ServiceResultType.NotFound, "Adresse nicht gefunden.");

            // Sicherheits-Check
            if (address.CustomerId != null)
            {
                return ServiceResult.Fail(ServiceResultType.Forbidden, "Kundenadressen können hier nicht gelöscht werden.");
            }

            // Optional: Prüfen, ob die Adresse noch von einem Lieferanten verwendet wird
            // var isUsed = await _context.Suppliers.AnyAsync(s => s.AddressId == addressId);
            // if(isUsed) return ServiceResult.Fail(ServiceResultType.Conflict, "Adresse wird noch von einem Lieferanten verwendet.");

            await _addressRepository.DeleteAsync(addressId);
            return ServiceResult.Ok();
        }

        // MapToDto bleibt gleich
        private AddressDto MapToDto(Address address)
        {
            return new AddressDto
            {
                Id = address.Id,
                FirstName = address.FirstName,
                LastName = address.LastName,
                Street = address.Street,
                HouseNumber = address.HouseNumber,
                City = address.City,
                PostalCode = address.PostalCode,
                Country = address.Country,
                Type = address.Type
            };
        }
    }
}