using PostFundManagement.Application.Abstractions.Services;
using PostFundManagement.Domain;
using PostFundManagement.Domain.Errors;
using PostFundManagement.Domain.Extensions;
using PostFundManagement.Domain.Models;
using PostFundManagement.Infrastructure.Database;

namespace PostFundManagement.Application.Services.Users;

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

            var user = await context.Users.FirstOrDefaultAsync(u => u.Id == userId, cancellationToken);

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

                context.Users.Update(user);
            }

            return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
        }));

    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.Users.AsNoTracking();

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

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

            if (!string.IsNullOrWhiteSpace(request.SortBy))
                query = request.SortBy.ToLowerInvariant() switch
                {
                    "email" => request.SortDescending ? query.OrderByDescending(u => u.Email) : query.OrderBy(u => u.Email),
                    "lastloginat" => request.SortDescending ? query.OrderByDescending(u => u.LastLoginAt) : query.OrderBy(u => u.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.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.Users
                .Where(f => f.Id == userId)
                .ExecuteUpdateAsync(f => f.SetProperty(u => u.Status, status), cancellationToken);

            return Result.OkIf(changedTotal > 0, UpdateError.New);
        }));

    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 user = await context.Users.AsNoTracking()
                .FirstOrDefaultAsync(f => f.Id == userId, cancellationToken);

            return Result.FailIf(user == null, NotFoundError.New)
                .ToResult(user?.Map()!);
        }));
}