using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System;
using System.Linq;
using System.Threading.Tasks;
using vita_asistente.Models;

namespace vita_asistente.Controllers
{
    [Authorize(Roles = "Admin")]
    public class UsuariosController : Controller
    {
        private readonly UserManager<ApplicationUser> _userManager;
        private readonly RoleManager<IdentityRole> _roleManager;

        public UsuariosController(UserManager<ApplicationUser> userManager, RoleManager<IdentityRole> roleManager)
        {
            _userManager = userManager;
            _roleManager = roleManager;
        }

        // GET: Usuarios
        public async Task<IActionResult> Index()
        {
            var usuarios = await _userManager.Users.ToListAsync();
            return View(usuarios);
        }

        // GET: Usuarios/Details/5
        public async Task<IActionResult> Details(string id)
        {
            if (id == null) return NotFound();
            var usuario = await _userManager.FindByIdAsync(id);
            if (usuario == null) return NotFound();
            var roles = await _userManager.GetRolesAsync(usuario);
            ViewBag.Roles = roles;
            return View(usuario);
        }

        // GET: Usuarios/Create
        public IActionResult Create()
        {
            return View();
        }

        // POST: Usuarios/Create
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> Create(ApplicationUser usuario, string password)
        {
            if (ModelState.IsValid)
            {
                var user = new ApplicationUser
                {
                    UserName = usuario.Email,
                    Email = usuario.Email,
                    Nombre = usuario.Nombre,
                    Apellido = usuario.Apellido,
                    Documento = usuario.Documento,
                    Direccion = usuario.Direccion,
                    // RolPrincipal se asigna después
                };
                var result = await _userManager.CreateAsync(user, password);
                if (result.Succeeded)
                {
                    // Asignar un rol por defecto (por ejemplo "Usuario" si existe)
                    if (await _roleManager.RoleExistsAsync("Usuario"))
                    {
                        await _userManager.AddToRoleAsync(user, "Usuario");
                    }
                    return RedirectToAction(nameof(Index));
                }
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError(string.Empty, error.Description);
                }
            }
            return View(usuario);
        }

        // GET: Usuarios/Edit/5
        public async Task<IActionResult> Edit(string id)
        {
            if (id == null) return NotFound();
            var usuario = await _userManager.FindByIdAsync(id);
            if (usuario == null) return NotFound();
            return View(usuario);
        }

        // POST: Usuarios/Edit/5
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> Edit(string id, ApplicationUser usuarioActualizado)
        {
            if (id != usuarioActualizado.Id) return NotFound();
            if (ModelState.IsValid)
            {
                var usuario = await _userManager.FindByIdAsync(id);
                if (usuario == null) return NotFound();

                // Actualizar solo los campos permitidos
                usuario.Nombre = usuarioActualizado.Nombre;
                usuario.Apellido = usuarioActualizado.Apellido;
                usuario.Documento = usuarioActualizado.Documento;
                usuario.Direccion = usuarioActualizado.Direccion;
                usuario.Email = usuarioActualizado.Email;
                usuario.UserName = usuarioActualizado.Email;

                var result = await _userManager.UpdateAsync(usuario);
                if (result.Succeeded)
                {
                    return RedirectToAction(nameof(Index));
                }
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError(string.Empty, error.Description);
                }
            }
            return View(usuarioActualizado);
        }

        // GET: Usuarios/Delete/5
        public async Task<IActionResult> Delete(string id)
        {
            if (id == null) return NotFound();
            var usuario = await _userManager.FindByIdAsync(id);
            if (usuario == null) return NotFound();
            return View(usuario);
        }

        // POST: Usuarios/Delete/5
        [HttpPost, ActionName("Delete")]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> DeleteConfirmed(string id)
        {
            var usuario = await _userManager.FindByIdAsync(id);
            if (usuario != null)
            {
                var result = await _userManager.DeleteAsync(usuario);
                if (!result.Succeeded)
                {
                    foreach (var error in result.Errors)
                    {
                        ModelState.AddModelError(string.Empty, error.Description);
                    }
                }
            }
            return RedirectToAction(nameof(Index));
        }

        // GET: Usuarios/ManageRoles/5
        public async Task<IActionResult> ManageRoles(string id)
        {
            if (id == null) return NotFound();
            var usuario = await _userManager.FindByIdAsync(id);
            if (usuario == null) return NotFound();

            var rolesDelUsuario = await _userManager.GetRolesAsync(usuario);
            var todosLosRoles = await _roleManager.Roles.ToListAsync();

            var model = new ManageRolesViewModel
            {
                UsuarioId = usuario.Id,
                UsuarioNombre = $"{usuario.Nombre} {usuario.Apellido}",
                RolesDisponibles = todosLosRoles.Select(r => new RoleCheckbox
                {
                    RoleId = r.Id,
                     RoleName = r.Name ?? string.Empty,
                     IsSelected = rolesDelUsuario.Contains(r.Name ?? string.Empty)
                }).ToList()
            };
            return View(model);
        }

        // POST: Usuarios/ManageRoles
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> ManageRoles(ManageRolesViewModel model)
        {
            var usuario = await _userManager.FindByIdAsync(model.UsuarioId);
            if (usuario == null) return NotFound();

            var rolesDelUsuario = await _userManager.GetRolesAsync(usuario);
            var rolesSeleccionados = model.RolesDisponibles.Where(r => r.IsSelected).Where(r => !string.IsNullOrEmpty(r.RoleName)).Select(r => r.RoleName).ToList();

            // Remover roles que ya no están seleccionados
            var rolesAEliminar = rolesDelUsuario.Except(rolesSeleccionados).ToList();
            foreach (var rol in rolesAEliminar)
            {
                await _userManager.RemoveFromRoleAsync(usuario, rol);
            }

            // Agregar roles nuevos
            var rolesAAgregar = rolesSeleccionados.Except(rolesDelUsuario).ToList();
            foreach (var rol in rolesAAgregar)
            {
                await _userManager.AddToRoleAsync(usuario, rol);
            }

            return RedirectToAction(nameof(Index));
        }
    }

    // ViewModels para la gestión de roles (dentro del mismo archivo por simplicidad)
    public class ManageRolesViewModel
    {
        public required string UsuarioId { get; set; }
        public required string UsuarioNombre { get; set; }
        public required List<RoleCheckbox> RolesDisponibles { get; set; }
    }

public class RoleCheckbox
    {
        public required string RoleId { get; set; }
        public required string RoleName { get; set; }
        public bool IsSelected { get; set; }
    }
}