using PostFundManagement.Application.Abstractions.Services;
using PostFundManagement.Application.Services.Shared;
using PostFundManagement.Domain;
using PostFundManagement.Domain.Abstractions;
using PostFundManagement.Domain.Errors;
using PostFundManagement.Domain.Extensions;
using PostFundManagement.Domain.Models;
using PostFundManagement.Domain.Models.Security;
using PostFundManagement.Infrastructure.Database;
using Claim = PostFundManagement.Domain.Models.Security.Claim;

namespace PostFundManagement.Application.Services.Users;

public sealed class UserService(IDbContextFactory<ApplicationDbContext> contextFactory, ITenantContextService tenantContext,
    ISkorubaUserService skorubaService, HashService hashService) : IUserService
{
    public async Task<Result> SyncUserAsync(Guid userId, string email, string role, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result>>)(async () =>
        {
            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            if (string.IsNullOrWhiteSpace(role))
                return Result.Fail(ValidationError.Create("Failed to sync, user role not present, contact support"));

            var tenantUser = await context.TenantUsers
                .Include(i => i.User)
                .FirstOrDefaultAsync(u => u.UserId == userId, cancellationToken);

            if (tenantUser is null)
            {
                context.Users.Add(new Domain.Entities.User
                {
                    Id = userId,
                    Email = email,
                    Status = ActivityStatus.Active,
                    LastLoginAt = DateTime.UtcNow,
                    Role = role
                });

                context.TenantUsers.Add(new Domain.Entities.TenantUser
                {
                    CreatedAt = DateTime.UtcNow,
                    CreatedBy = userId,
                    Status = ActivityStatus.Active,
                    TenantId = tenantContext.TenantId,
                    UserId = userId
                });
            }
            else
            {
                tenantUser.User!.Email = email;
                tenantUser.User.LastLoginAt = DateTime.UtcNow;
                tenantUser.User.Role = role;

                context.Users.Update(tenantUser.User);
            }

            return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.Create("Failed to sync user, contact support"));
        }));

    public async Task<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result<User[]>>>)(async () =>
        {
            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var query = context.TenantUsers.Include(i => i.User).AsNoTracking();

            if (request.Status.HasValue)
                query = query.Where(u => u.Status == request.Status.Value);

            if (!string.IsNullOrWhiteSpace(request.Email))
                query = query.Where(u => u.User!.Email != null && u.User!.Email.Contains(request.Email));

            if (!string.IsNullOrWhiteSpace(request.SortBy))
                query = request.SortBy.ToLowerInvariant() switch
                {
                    "email" => request.SortDescending ? query.OrderByDescending(u => u.User!.Email) : query.OrderBy(u => u.User!.Email),
                    "lastloginat" => request.SortDescending ? query.OrderByDescending(u => u.User!.LastLoginAt) : query.OrderBy(u => u.User!.LastLoginAt),
                    "status" => request.SortDescending ? query.OrderByDescending(u => u.Status) : query.OrderBy(u => u.Status),
                    _ => request.SortDescending ? query.OrderByDescending(u => u.Id) : query.OrderBy(u => u.Id)
                };
            else
                query = query.OrderBy(u => u.Id);

            var users = await query.Skip((pagination.Page - 1) * pagination.PageSize)
                .Take(pagination.PageSize).ToListAsync(cancellationToken);

            return Result.Ok(users.Select(u => u.User!.Map()).ToArray());
        }));

    public async Task<Result> UpdateUserStatusAsync(Guid userId, ActivityStatus status, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result>>)(async () =>
        {
            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var changedTotal = await context.TenantUsers
                .Include(i => i.User)
                .Where(f => f.UserId == userId)
                .ExecuteUpdateAsync(f => f
                    .SetProperty(u => u.Status, status), cancellationToken);

            changedTotal += await context.Users.Where(f => f.Id == userId)
                .ExecuteUpdateAsync(f => f.SetProperty(u => u.Status, status), cancellationToken);

            return Result.OkIf(changedTotal > 0, UpdateError.Create("Failed to update user status."));
        }));

    public async Task<Result<User>> GetUserAsync(Guid userId, CancellationToken cancellationToken) =>
        await Result.Try((Func<Task<Result<User>>>)(async () =>
        {
            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var tenantUser = await context.TenantUsers.AsNoTracking()
                .Include(i => i.User)
                .FirstOrDefaultAsync(f => f.UserId == userId, cancellationToken);

            return Result.FailIf(tenantUser == null, NotFoundError.Create("User not found."))
                .ToResult(tenantUser!.User?.Map()!);
        }));

    public async Task<Result> CreateUserAsync(string tenantIdHash, string idNumberHash, CreateUserRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result>>)(async () =>
        {
            var tenantIdHashDecode = hashService.DecodeLongIdHash(tenantIdHash);

            if (tenantIdHashDecode.IsFailed)
                return Result.Fail(IdDecodeError.Create()
                    .CausedBy(tenantIdHashDecode.Errors));

            var tenantId = tenantIdHashDecode.Value;

            var idNumberHashDecode = await hashService.DecodeHexHash(idNumberHash);

            if (idNumberHashDecode.IsFailed)
                return Result.Fail(IdDecodeError.Create()
                    .CausedBy(idNumberHashDecode.Errors));

            var idNumber = idNumberHashDecode.Value.Trim();

            var email = request.Email?.Trim().ToLowerInvariant();

            if (string.IsNullOrWhiteSpace(email))
                return Result.Fail(ValidationError.Create("Email is required."));

            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            if (await context.Users.AnyAsync(u => u.Email == email, cancellationToken))
                return Result.Fail(ValidationError.Create("User with this email already exists."));

            var createUserResult = await skorubaService.CreateUserAsync(request, userId, cancellationToken);

            if (createUserResult.IsFailed)
                return Result.Fail(CreateError.Create("Failed to create user."));

            var newUserId = Guid.Parse(createUserResult.Value.Trim());

            var availableRolesResult = await skorubaService.GetAvailableRolesAsync(cancellationToken: cancellationToken);

            if (availableRolesResult.IsFailed)
                return Result.Fail(NotFoundError.Create("Failed to retrieve available roles."));

            var defaultRole = availableRolesResult.Value.FirstOrDefault(r => r.Name == "Contributor");

            if (defaultRole == null)
                return Result.Fail(NotFoundError.Create("Role 'Contributor' not found."));

            var roleAssignmentResult = await skorubaService.AddRoleAsync(newUserId, Guid.Parse(defaultRole.Id), cancellationToken);

            if (roleAssignmentResult.IsFailed)
                return Result.Fail(UpdateError.Create("Failed to assign role to user."));

            var newUser = context.Users.Add(new Domain.Entities.User
            {
                Id = newUserId,
                Email = email,
                Status = ActivityStatus.Active,
                LastLoginAt = DateTime.UtcNow,
                IdNumber = idNumber,
                Role = defaultRole.Name,
            });

            context.TenantUsers.Add(new Domain.Entities.TenantUser
            {
                CreatedAt = DateTime.UtcNow,
                CreatedBy = userId,
                Status = ActivityStatus.Active,
                TenantId = tenantId,
                UserId = newUserId,
            });

            return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.Create("Failed to create user, contact support"));
        }));

    public async Task<Result> DeleteUserClaimAsync(string claimIdHash, Guid targetUserId, Guid userId, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result>>)(async () =>
        {
            var claimIdHashDecode = hashService.DecodeIntIdHash(claimIdHash);

            if (claimIdHashDecode.IsFailed)
                return Result.Fail(IdDecodeError.Create()
                    .CausedBy(claimIdHashDecode.Errors));

            var claimId = claimIdHashDecode.Value;

            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            if (!await context.Users.AnyAsync(u => u.Id == targetUserId, cancellationToken))
                return Result.Fail(NotFoundError.Create("User not found."));

            var claimDeleteResult = await skorubaService.RemoveClaimAsync(targetUserId, claimId, cancellationToken);

            return Result.OkIf(claimDeleteResult.IsSuccess, ValidationError.Create("Failed to delete user claim.")
                .CausedBy(claimDeleteResult.Errors));
        }));

    public async Task<Result> SetUserLockoutAsync(Guid targetUserId, Guid userId, bool disable, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result>>)(async () =>
        {
            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var lockoutResult = await skorubaService.SetUserLockoutAsync(targetUserId, disable, cancellationToken);

            if(lockoutResult.IsFailed)
                return Result.Fail(UpdateError.Create("Failed to set user lockout.")
                    .CausedBy(lockoutResult.Errors));

            var changedTotal = await context.Users.Where(f => f.Id == targetUserId)
                .ExecuteUpdateAsync(f => f.SetProperty(u => u.Status, disable ? ActivityStatus.Disabled : ActivityStatus.Active), cancellationToken);

            changedTotal += await context.TenantUsers.Where(f => f.UserId == targetUserId)
                .ExecuteUpdateAsync(f => f.SetProperty(u => u.Status, disable ? ActivityStatus.Disabled : ActivityStatus.Active), cancellationToken);

            return Result.OkIf(lockoutResult.IsSuccess && changedTotal > 0, ValidationError.Create("Failed to set user lockout.")
                .CausedBy(lockoutResult.Errors));
        }));

    public async Task<Result> LogoutUserAsync(Guid targetUserId, Guid userId, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result>>)(async () =>
        {
            var logoutResult = await skorubaService.InvalidateUserSessionAsync(targetUserId, cancellationToken);

            return Result.OkIf(logoutResult.IsSuccess, ValidationError.Create("Failed to logout user.")
                .CausedBy(logoutResult.Errors));
        }));

    public async Task<Result<Role[]>> GetUserRolesAsync(Guid targetUserId, Guid userId, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result<Role[]>>>)(async () => 
            await skorubaService.GetUserRolesAsync(targetUserId, cancellationToken: cancellationToken)));

    public async Task<Result<Claim[]>> GetUserClaimsAsync(Guid targetUserId, Guid userId, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result<Claim[]>>>)(async () => 
            await skorubaService.GetUserClaimsAsync(targetUserId, cancellationToken: cancellationToken)));

    public async Task<Result<Role[]>> GetSystemRolesAsync(Guid userId, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result<Role[]>>>)(async () => 
            await skorubaService.GetAvailableRolesAsync(cancellationToken: cancellationToken)));

    public async Task<Result> DeleteUserRoleAsync(Guid targetUserId, Guid roleId, Guid userId, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result>>)(async () =>
        {
            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var changedTotal = await context.Users.Where(f => f.Id == targetUserId)
                .ExecuteUpdateAsync(f => f.SetProperty(u => u.Role, string.Empty), cancellationToken);

            var roleDeleteResult = await skorubaService.RemoveRoleAsync(targetUserId, roleId, cancellationToken);

            return Result.OkIf(roleDeleteResult.IsSuccess && changedTotal > 0, ValidationError.Create("Failed to delete user role.")
                .CausedBy(roleDeleteResult.Errors));
        }));

    public async Task<Result> AddUserClaimAsync(AddUserClaimRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result>>)(async () =>
        {
            var addClaimResult = await skorubaService.AddClaimAsync(request.UserId, request.ClaimType, request.ClaimValue, cancellationToken);

            return Result.OkIf(addClaimResult.IsSuccess, ValidationError.Create("Failed to add user claim.")
                .CausedBy(addClaimResult.Errors));
        }));

    public async Task<Result> AddUserRoleAsync(Guid targetUserId, Guid roleId, Guid userId, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result>>)(async () =>
        {
            var userRolesResult = await skorubaService.GetUserRolesAsync(targetUserId, cancellationToken: cancellationToken);

            if (userRolesResult.IsFailed)
                return Result.Fail(NotFoundError.Create("Failed to retrieve user roles.")
                    .CausedBy(userRolesResult.Errors));

            foreach (var role in userRolesResult.Value)
            {
                var deleteRoleResult = await skorubaService.RemoveRoleAsync(targetUserId, Guid.Parse(role.Id), cancellationToken);

                if (deleteRoleResult.IsFailed)
                    return Result.Fail(UpdateError.Create("Failed to remove existing user role.")
                        .CausedBy(deleteRoleResult.Errors));
            }

            var roleAddResult = await skorubaService.AddRoleAsync(targetUserId, roleId, cancellationToken);

            if(roleAddResult.IsFailed)
                return Result.Fail(UpdateError.Create("Failed to add user role.")
                    .CausedBy(roleAddResult.Errors));

            var systemRoles = await skorubaService.GetAvailableRolesAsync(cancellationToken: cancellationToken);

            if (systemRoles.IsFailed)
                return Result.Fail(NotFoundError.Create("Failed to retrieve system roles.")
                    .CausedBy(systemRoles.Errors));

            var targetRole = systemRoles.Value.FirstOrDefault(r => r.Id == roleId.ToString());

            if (targetRole == null)
                return Result.Fail(NotFoundError.Create("Role not found."));

            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var changedTotal = await context.Users.Where(f => f.Id == targetUserId)
                .ExecuteUpdateAsync(f => f.SetProperty(u => u.Role, targetRole.Name), cancellationToken);

            return Result.OkIf(roleAddResult.IsSuccess && changedTotal > 0, ValidationError.Create("Failed to add user role.")
                .CausedBy(roleAddResult.Errors));
        }));

    public async Task<Result<Claim[]>> GetRoleClaimsAsync(Guid roleId, Guid userId, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result<Claim[]>>>)(async () =>
            await skorubaService.GetRoleClaimsAsync(roleId, cancellationToken)));
}