// 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.DTOs.Users;
using Webshop.Application.Services.Admin.Interfaces;
using Webshop.Domain.Entities;
using Webshop.Infrastructure.Data; // WICHTIG: Stellt sicher, dass ApplicationDbContext gefunden wird.
using Webshop.Domain.Identity;

namespace Webshop.Application.Services.Admin
{
    // --- SCHRITT 1: Die fehlende Klassendeklaration ---
    public class AdminUserService : IAdminUserService
    {
        // --- SCHRITT 2: Die fehlenden Feld-Deklarationen ---
        private readonly UserManager<ApplicationUser> _userManager;
        private readonly ApplicationDbContext _context;

        // --- SCHRITT 3: Der Konstruktor, der die Felder zuweist ---
        public AdminUserService(UserManager<ApplicationUser> userManager, ApplicationDbContext context)
        {
            _userManager = userManager;
            _context = context;
        }

        // --- AB HIER: Alle Ihre Methoden, unverändert ---
        public async Task<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 userDtos;
        }

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

            if (user == null)
            {
                return null;
            }

            return 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
            };
        }

        public async Task<bool> UpdateUserRolesAsync(string userId, List<string> newRoles)
        {
            var user = await _userManager.FindByIdAsync(userId);
            if (user == null)
            {
                return false;
            }

            var existingRoles = await _userManager.GetRolesAsync(user);
            var removeResult = await _userManager.RemoveFromRolesAsync(user, existingRoles);
            if (!removeResult.Succeeded)
            {
                return false;
            }

            var addResult = await _userManager.AddToRolesAsync(user, newRoles);
            return addResult.Succeeded;
        }

        public async Task<bool> DeleteUserAsync(string userId)
        {
            var user = await _userManager.FindByIdAsync(userId);
            if (user == null)
            {
                return false;
            }

            // 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);
            return result.Succeeded;
        }

    } // <-- Schließende Klammer für die Klasse
} // <-- Schließende Klammer für den Namespace