using PostFundManagement.Domain;
using PostFundManagement.Domain.Abstractions;
using PostFundManagement.Domain.Extensions;
using PostFundManagement.Domain.Models;
using PostFundManagement.Infrastructure.Database;

namespace PostFundManagement.Application.Services.Users;

public sealed class UserService(IDbContextFactory<ApplicationDbContext> contextFactory) : IService
{
    public async ValueTask<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken =  default)
    {
        try
        {
            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 await context.SaveChangesAsync(cancellationToken) > 0
                ? Result.Ok()
                : Result.Fail("Failed to sync user");
        }
        catch (Exception ex)
        {
            return Result.Fail(new Error(ex.Message).CausedBy(ex));
        }
    }

    public async ValueTask<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default)
    {
		try
		{
            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 totalCount = await query.CountAsync(cancellationToken);

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

            return Result.Ok(users?.Select(u => u.Map()).ToArray() ?? []);
        }
		catch (Exception ex)
		{
			return Result.Fail(new Error(ex.Message).CausedBy(ex));
		}
    }
}