using AppContext.Entities;
using Converters;
using Microsoft.EntityFrameworkCore;
using Model;
using Services;
using Services.Failures;


namespace DbServices;

public class DbUserService(AppContext.AppContext context) : IUserService
{
    public Task<int> UsersCount(string nameNeedle)
    {
        return context.Users.CountAsync(u => u.Name.ToLower().Contains(nameNeedle.ToLower()));
    }

    public Task<int> UsersCount()
    {
        return context.Users.CountAsync();
    }

    public Task<IEnumerable<User>> ListUsers(string nameNeedle)
    {
        return Task.FromResult(
            context.Users
                .Where(n => n.Name.ToLower().Contains(nameNeedle.ToLower()))
                .AsEnumerable()
                .Select(e => e.ToModel())
        );
    }

    public Task<IEnumerable<User>> ListUsers()
    {
        return Task.FromResult(
            context.Users
                .AsEnumerable()
                .Select(e => e.ToModel())
        );
    }

    public async Task<User?> GetUser(int id)
    {
        return (await context.Users.FirstOrDefaultAsync(e => e.Id == id))?.ToModel();
    }

    public async Task<User?> GetUser(string email)
    {
        return (await context.Users.FirstOrDefaultAsync(e => e.Email == email))?.ToModel();
    }
    
    public async Task<User> CreateUser(string username, string email, string password, string profilePicture,
        bool isAdmin)
    {
        var userEntity = new UserEntity
        {
            Name = username,
            Email = email,
            Password = password,
            ProfilePicture = profilePicture,
            IsAdmin = isAdmin
        };

        await context.Users.AddAsync(userEntity);
        await context.SaveChangesAsync();

        return userEntity.ToModel();
    }

    public async Task<bool> RemoveUsers(params int[] identifiers)
    {
        return await context.Users.Where(u => identifiers.Contains(u.Id)).ExecuteDeleteAsync() > 0;
    }

    public async Task UpdateUser(User user)
    {
        var entity = await context.Users.FirstOrDefaultAsync(e => e.Id == user.Id);
        if (entity == null)
            throw new ServiceException(Failure.NotFound("User not found"));

        entity.ProfilePicture = user.ProfilePicture;
        entity.Name = user.Name;
        entity.Email = user.Email;
        entity.Id = user.Id;
        entity.IsAdmin = user.IsAdmin;
        
        await context.SaveChangesAsync();
    }

    public async Task<User?> Authorize(string email, string password)
    {
        return (await context
                .Users
                .FirstOrDefaultAsync(u => u.Email == email))
            ?.ToModel();
    }

    public async Task<IEnumerable<Tactic>> GetSharedTacticsToUser(int userId)
    {
        var sharedTactics = await context.SharedTactics
            .Where(st => st.SharedWithUserId == userId)
            .ToListAsync();

        var tactics = new List<Tactic>();
        foreach (var sharedTactic in sharedTactics)
        {
            var tactic = await context.Tactics
                .Where(t => t.Id == sharedTactic.TacticId)
                .Select(t => t.ToModel())
                .FirstOrDefaultAsync();

            if (tactic != null)
            {
                tactics.Add(tactic);
            }
        }

        return tactics;
    }
}