using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Auth.Domain.Entities.HR;
using Auth.Domain.Entities;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Auth.Contracts.DTOs.Users;
using System.Security.Claims;

namespace Auth.API.Endpoints.v1.UserEndpoints;

public static class RoleMap
{
    public static RouteGroupBuilder RoleEndpoints(this RouteGroupBuilder group)
    {

        
    
        group.MapPost(
            "role-management/{role}/user/{userId}",
            async ([FromRoute] string userId, [FromRoute] string role,  UserManager<AppUser> userManager) =>
            {
                try
                {
                    var user = await userManager.Users.FirstOrDefaultAsync(x => x.Id == userId);
                    if (user is null)
                        return Results.BadRequest();

                    var result = await userManager.AddToRoleAsync(user, role);
                    if (!result.Succeeded)
                        return Results.BadRequest();
                    return Results.Ok();
                }
                catch
                {
                    return Results.StatusCode(500);
                }
            }
        );

        group.MapDelete(
            "role-management/{role}/user/{userid}",
            async (string role, string userId, UserManager<AppUser> userManager) =>
            {
                try
                {
                    var user = await userManager.Users.FirstOrDefaultAsync(x => x.Id == userId);
                    if (user is null)
                        return Results.BadRequest();

                    var result = await userManager.RemoveFromRoleAsync(user, role);
                    if (!result.Succeeded)
                        return Results.BadRequest();

                    return Results.Ok();
                }
                catch
                {
                    return Results.StatusCode(500);
                }
            }
        );

        group.MapGet(
            "role-management/roles",
            async (RoleManager<IdentityRole> roleManager) =>
            {
                var roles = await roleManager.Roles.ToListAsync();
                return Results.Ok(roles);
            }
        ).RequireAuthorization();

        group.MapPost(
            "role-management/roles",
            async ([FromBody] RoleVM roleVM, RoleManager<IdentityRole> roleManager) =>
            {
                if (string.IsNullOrEmpty(roleVM.Name)) return Results.BadRequest("Role Name is required.");

                var roleExists = await roleManager.RoleExistsAsync(roleVM.Name);
                if (roleExists) return Results.Conflict("Role already exists.");

                var result = await roleManager.CreateAsync(new IdentityRole(roleVM.Name));
                return result.Succeeded ? Results.Ok() : Results.BadRequest(result.Errors);
            }
        ).RequireAuthorization();

        group.MapDelete(
            "role-management/roles/{id}",
            async (string id, RoleManager<IdentityRole> roleManager) =>
            {
                var role = await roleManager.FindByIdAsync(id);
                if (role == null) return Results.NotFound();

                var result = await roleManager.DeleteAsync(role);
                return result.Succeeded ? Results.Ok() : Results.BadRequest(result.Errors);
            }
        ).RequireAuthorization();

        group.MapGet("role-management/roles/{id}/permissions", async (string id, RoleManager<IdentityRole> roleManager) =>
        {
            var role = await roleManager.FindByIdAsync(id);
            if (role == null) return Results.NotFound("Role not found.");

            var claims = await roleManager.GetClaimsAsync(role);
            return Results.Ok(claims.Select(c => c.Value));
        }).RequireAuthorization();

        group.MapPost("role-management/roles/{id}/permissions", async (string id, [FromBody] string permission, RoleManager<IdentityRole> roleManager) =>
        {
            var role = await roleManager.FindByIdAsync(id);
            if (role == null) return Results.NotFound("Role not found.");

            var result = await roleManager.AddClaimAsync(role, new Claim("Permission", permission));
            return result.Succeeded ? Results.Ok() : Results.BadRequest(result.Errors);
        }).RequireAuthorization();

        group.MapDelete("role-management/roles/{id}/permissions", async (string id, [FromBody] string permission, RoleManager<IdentityRole> roleManager) =>
        {
            var role = await roleManager.FindByIdAsync(id);
            if (role == null) return Results.NotFound("Role not found.");

            var result = await roleManager.RemoveClaimAsync(role, new Claim("Permission", permission));
            return result.Succeeded ? Results.Ok() : Results.BadRequest(result.Errors);
        }).RequireAuthorization();

        return group;
    }
}