// src/Webshop.Application/Services/Admin/AdminUserService.cs
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Webshop.Application;
using Webshop.Application.DTOs.Users;
using Webshop.Application.Services.Admin.Interfaces;
using Webshop.Domain.Identity;
using Webshop.Infrastructure.Data;

namespace Webshop.Application.Services.Admin
{
    public class AdminUserService : IAdminUserService
    {
        private readonly UserManager<ApplicationUser> _userManager;
        private readonly ApplicationDbContext _context;

        public AdminUserService(UserManager<ApplicationUser> userManager, ApplicationDbContext context)
        {
            _userManager = userManager;
            _context = context;
        }

        public async Task<ServiceResult<IEnumerable<UserDto>>> GetAllUsersAsync()
        {
            var users = await _userManager.Users
                .Include(u => u.Customer)
                .ToListAsync();

            var userDtos = new List<UserDto>();
            foreach (var user in users)
            {
                userDtos.Add(new UserDto
                {
                    Id = user.Id,
                    Email = user.Email ?? string.Empty,
                    UserName = user.UserName ?? string.Empty,
                    CreatedDate = user.CreatedDate,
                    EmailConfirmed = user.EmailConfirmed,
                    Roles = (await _userManager.GetRolesAsync(user)).ToList(),
                    LastActive = user.LastActive,
                    FirstName = user.Customer?.FirstName ?? string.Empty,
                    LastName = user.Customer?.LastName ?? string.Empty
                });
            }
            return ServiceResult.Ok<IEnumerable<UserDto>>(userDtos);
        }

        public async Task<ServiceResult<UserDto>> GetUserByIdAsync(string userId)
        {
            var user = await _userManager.Users
                .Include(u => u.Customer)
                .FirstOrDefaultAsync(u => u.Id == userId);

            if (user == null)
            {
                return ServiceResult.Fail<UserDto>(ServiceResultType.NotFound, $"Benutzer mit ID '{userId}' nicht gefunden.");
            }

            var userDto = new UserDto
            {
                Id = user.Id,
                Email = user.Email ?? string.Empty,
                UserName = user.UserName ?? string.Empty,
                CreatedDate = user.CreatedDate,
                EmailConfirmed = user.EmailConfirmed,
                Roles = (await _userManager.GetRolesAsync(user)).ToList(),
                LastActive = user.LastActive,
                FirstName = user.Customer?.FirstName ?? string.Empty,
                LastName = user.Customer?.LastName ?? string.Empty
            };

            return ServiceResult.Ok(userDto);
        }

        public async Task<ServiceResult> UpdateUserRolesAsync(string userId, List<string> newRoles)
        {
            var user = await _userManager.FindByIdAsync(userId);
            if (user == null)
            {
                return ServiceResult.Fail(ServiceResultType.NotFound, $"Benutzer mit ID '{userId}' nicht gefunden.");
            }

            var existingRoles = await _userManager.GetRolesAsync(user);
            var removeResult = await _userManager.RemoveFromRolesAsync(user, existingRoles);
            if (!removeResult.Succeeded)
            {
                string errors = string.Join(", ", removeResult.Errors.Select(e => e.Description));
                return ServiceResult.Fail(ServiceResultType.Failure, $"Fehler beim Entfernen alter Rollen: {errors}");
            }

            var addResult = await _userManager.AddToRolesAsync(user, newRoles);
            if (!addResult.Succeeded)
            {
                string errors = string.Join(", ", addResult.Errors.Select(e => e.Description));
                return ServiceResult.Fail(ServiceResultType.Failure, $"Fehler beim Hinzufügen neuer Rollen: {errors}");
            }

            return ServiceResult.Ok();
        }

        public async Task<ServiceResult> DeleteUserAsync(string userId)
        {
            var user = await _userManager.FindByIdAsync(userId);
            if (user == null)
            {
                return ServiceResult.Fail(ServiceResultType.NotFound, $"Benutzer mit ID '{userId}' nicht gefunden.");
            }

            // Kaskadierendes Löschen der abhängigen Daten
            var customer = await _context.Customers
                .Include(c => c.Orders)
                .Include(c => c.Reviews)
                .Include(c => c.Addresses)
                .FirstOrDefaultAsync(c => c.AspNetUserId == userId);

            if (customer != null)
            {
                _context.Reviews.RemoveRange(customer.Reviews);
                _context.Orders.RemoveRange(customer.Orders);
                _context.Addresses.RemoveRange(customer.Addresses);
                _context.Customers.Remove(customer);
                await _context.SaveChangesAsync();
            }

            // Zum Schluss den Identity-Benutzer löschen
            var result = await _userManager.DeleteAsync(user);
            if (!result.Succeeded)
            {
                string errors = string.Join(", ", result.Errors.Select(e => e.Description));
                return ServiceResult.Fail(ServiceResultType.Failure, $"Fehler beim Löschen des Benutzers: {errors}");
            }

            return ServiceResult.Ok();
        }
    }
}