using Lieb.Models;
using Lieb.Models.GuildWars2;
using Lieb.Models.GuildWars2.Raid;
using Microsoft.EntityFrameworkCore;

namespace Lieb.Data
{
    public class RaidService
    {
        private readonly IDbContextFactory<LiebContext> _contextFactory;
        private readonly DiscordService _discordService;

        public RaidService(IDbContextFactory<LiebContext> contextFactory, DiscordService discordService)
        {
            _contextFactory = contextFactory;
            _discordService = discordService;
        }

        public List<Raid> GetRaids()
        {
            using var context = _contextFactory.CreateDbContext();
            return context.Raids
                .Include(r => r.Roles)
                .Include(r => r.Reminders)
                .Include(r => r.SignUps)
                .ThenInclude(s => s.LiebUser)
                .Include(r => r.SignUps)
                .ThenInclude(s => s.GuildWars2Account)
                .Include(r => r.SignUps)
                .ThenInclude(s => s.RaidRole)
                .Include(r => r.DiscordRaidMessages)
                .ToList();
        }

        public Raid GetRaid(int raidId)
        {
            using var context = _contextFactory.CreateDbContext();
            Raid raid = context.Raids
                .Include(r => r.Roles)
                .Include(r => r.Reminders)
                .Include(r => r.SignUps)
                .ThenInclude(s => s.LiebUser)
                .Include(r => r.SignUps)
                .ThenInclude(s => s.GuildWars2Account)
                .Include(r => r.SignUps)
                .ThenInclude(s => s.RaidRole)
                .Include(r => r.DiscordRaidMessages)
                .FirstOrDefault(r => r.RaidId == raidId);
            if(raid != null) return raid;
            else return new Raid();
        }

        public async Task AddOrEditRaid(Raid raid, List<RaidRole> rolesToDelete, List<RaidReminder> remindersToDelete, List<DiscordRaidMessage> messagesToDelete, ulong? changedBy)
        {
            if (raid != null)
            {
                using var context = _contextFactory.CreateDbContext();
                if (raid.RaidId == 0)
                {
                    context.Raids.Add(raid);
                }
                else
                {
                    context.Update(raid);
                    context.RaidRoles.RemoveRange(rolesToDelete);
                    context.RaidReminders.RemoveRange(remindersToDelete);
                    context.DiscordRaidMessages.RemoveRange(messagesToDelete);
                    await _discordService.DeleteRaidMessages(messagesToDelete);

                    //move users back to "Random" role
                    if (raid.RaidType != RaidType.Planned)
                    {
                        RaidRole randomRole = raid.Roles.FirstOrDefault(r => r.IsRandomSignUpRole, CreateRandomSignUpRole(raid.RaidType));
                        foreach (RaidSignUp signUp in raid.SignUps)
                        {
                            signUp.RaidRole = randomRole;
                        }
                        context.RaidRoles.RemoveRange(raid.Roles.Where(r => !r.IsRandomSignUpRole));
                    }
                }
                await context.SaveChangesAsync();
                await _discordService.PostRaidMessage(raid.RaidId);
            }
        }

        public async Task DeleteRaid(int raidId, ulong? userId)
        {
            using var context = _contextFactory.CreateDbContext();
            Raid raid = GetRaid(raidId);
            await _discordService.DeleteRaidMessages(raid);
            if(raid.EndTimeUTC > DateTimeOffset.UtcNow)
            {
                await _discordService.SendMessageToRaidUsers($"Raid \"{raid.Title}\": was deleted.", raid);
            }

            context.RaidSignUps.RemoveRange(raid.SignUps);
            context.RaidRoles.RemoveRange(raid.Roles);
            context.RaidReminders.RemoveRange(raid.Reminders);
            context.DiscordRaidMessages.RemoveRange(raid.DiscordRaidMessages);
            await context.SaveChangesAsync();

            raid.SignUps.Clear();
            raid.Roles.Clear();
            raid.Reminders.Clear();
            raid.DiscordRaidMessages.Clear();
            context.Raids.Remove(raid);
            await context.SaveChangesAsync();
        }

        public async Task<bool> SignUp(int raidId, ulong liebUserId, int guildWars2AccountId, int plannedRoleId, SignUpType signUpType, ulong signedUpByUserId = 0)
        {
            using var context = _contextFactory.CreateDbContext();
            Raid? raid = context.Raids
            .Include(r => r.Roles)
            .Include(r => r.SignUps)
            .FirstOrDefault(r => r.RaidId == raidId);
            if(raid == null) return false;

            LiebUser user = context.LiebUsers.FirstOrDefault(l => l.Id == liebUserId);
            if(user == null) return false;

            bool result = false;
            if(raid.RaidType == RaidType.Planned)
            {
                result = await SignUpPlanned(raidId, liebUserId, guildWars2AccountId, plannedRoleId, signUpType, user.Name, signedUpByUserId);
            }
            else
            {
                result = await SignUpRandom(raidId, liebUserId, guildWars2AccountId, signUpType, user.Name, signedUpByUserId);
            }

            user.LastSignUpAt = DateTime.UtcNow;
            await context.SaveChangesAsync();
            await _discordService.PostRaidMessage(raidId);
            return result;
        }

        private async Task<bool> SignUpPlanned(int raidId, ulong liebUserId, int guildWars2AccountId, int plannedRoleId, SignUpType signUpType, string userName, ulong signedUpByUserId = 0)
        {
            if (!IsRoleSignUpAllowed(raidId, liebUserId, plannedRoleId, signUpType, true))
            {
                return false;
            }

            using var context = _contextFactory.CreateDbContext();


            List<RaidSignUp> signUps = context.RaidSignUps.Where(r => r.RaidId == raidId && r.LiebUserId == liebUserId).ToList();
            if (signUpType != SignUpType.Flex && signUps.Where(r => r.SignUpType != SignUpType.Flex).Any())
            {
                await ChangeSignUpType(raidId, liebUserId, signUpType, false);
                await ChangeRole(raidId, liebUserId, plannedRoleId, signUpType, RaidType.Planned, false);
                await ChangeAccount(raidId, liebUserId, guildWars2AccountId, false);
            }
            else if (!signUps.Where(r => r.RaidRoleId == plannedRoleId).Any())
            {
                RaidSignUp signUp = new RaidSignUp(raidId, liebUserId, guildWars2AccountId, plannedRoleId, signUpType);
                context.RaidSignUps.Add(signUp);
                await context.SaveChangesAsync();
                await LogSignUp(signUp, userName, signedUpByUserId);
            }
            else
            {
                return false;
            }
            return true;
        }

        private async Task<bool> SignUpRandom(int raidId, ulong liebUserId, int guildWars2AccountId, SignUpType signUpType, string userName, ulong signedUpByUserId = 0)
        {
            using var context = _contextFactory.CreateDbContext();
            if(signUpType == SignUpType.Flex) return false;

            Raid? raid = context.Raids
                .Include(r => r.Roles)
                .Include(r => r.SignUps)
                .FirstOrDefault(r => r.RaidId == raidId);

            GuildWars2Account account = context.GuildWars2Accounts
                                            .Include(a => a.EquippedBuilds)
                                            .ThenInclude(b => b.GuildWars2Build)
                                            .FirstOrDefault(a => a.GuildWars2AccountId == guildWars2AccountId);

            if(account == null) return false;
            if(!account.EquippedBuilds.Where(b => b.GuildWars2Build.UseInRandomRaid).Any()) return false;
            
            if(IsRandomRoleSignUpAllowed(raid, liebUserId, signUpType))
            {
                RaidSignUp signUp;
                if(raid.SignUps.Where(s => s.LiebUserId == liebUserId).Any())
                {
                    signUp = raid.SignUps.First(s => s.LiebUserId == liebUserId);
                    signUp.SignUpType = signUpType;
                }
                else
                {
                    RaidRole randomRole = raid.Roles.First(r => r.IsRandomSignUpRole);
                    signUp = new RaidSignUp(raid.RaidId, liebUserId, guildWars2AccountId, randomRole.RaidRoleId , signUpType);
                    context.RaidSignUps.Add(signUp);
                }
                await context.SaveChangesAsync();
                await LogSignUp(signUp, userName, signedUpByUserId);
                return true;
            }
            return false;
        }

        public async Task<bool> SignUpExternalUser(int raidId, string userName, int plannedRoleId, SignUpType signUpType, ulong signedUpByUserId)
        {
            if (!IsRoleSignUpAllowed(raidId, ulong.MaxValue, plannedRoleId, signUpType, true))
            {
                return false;
            }
            using var context = _contextFactory.CreateDbContext();

            
            RaidSignUp signUp = new RaidSignUp(raidId, userName, plannedRoleId, signUpType);
            context.RaidSignUps.Add(signUp);
            await context.SaveChangesAsync();
            await LogSignUp(signUp, userName, signedUpByUserId);
            await _discordService.PostRaidMessage(raidId);
            return true;
        }

        public async Task SignOff(int raidId, ulong liebUserId, ulong signedOffByUserId = 0)
        {
            using var context = _contextFactory.CreateDbContext();
            //remove Flex Sign Ups
            List<RaidSignUp> signUps = context.RaidSignUps.Where(x => x.RaidId == raidId && x.LiebUserId == liebUserId && x.SignUpType == SignUpType.Flex).ToList();
            context.RaidSignUps.RemoveRange(signUps);

            //change to SignedOff
            RaidSignUp? signUp = context.RaidSignUps.Include(s => s.LiebUser).FirstOrDefault(x => x.RaidId == raidId && x.LiebUserId == liebUserId && x.SignUpType != SignUpType.Flex);
            if (signUp != null)
            {
                signUp.SignUpType = SignUpType.SignedOff;
                await LogSignUp(signUp, signUp.LiebUser.Name, signedOffByUserId);
            }
            await context.SaveChangesAsync();
            await _discordService.PostRaidMessage(raidId);
        }

        public async Task SignOffExternalUser(int raidId, string userName, ulong signedOffByUserId)
        {
            using var context = _contextFactory.CreateDbContext();
            
            List<RaidSignUp> signUps = context.RaidSignUps.Where(x => x.RaidId == raidId && x.ExternalUserName == userName).ToList();
            context.RaidSignUps.RemoveRange(signUps);
            
            await context.SaveChangesAsync();
            RaidSignUp signUp = signUps.FirstOrDefault();
            if(signUp != null)
            {
                signUp.SignUpType = SignUpType.SignedOff;
                await LogSignUp(signUp, userName, signedOffByUserId);
            }
            await _discordService.PostRaidMessage(raidId);
        }

        public async Task ChangeAccount(int raidId, ulong liebUserId, int guildWars2AccountId, bool postChanges = true)
        {
            using var context = _contextFactory.CreateDbContext();
            List<RaidSignUp> signUps = context.RaidSignUps.Where(x => x.RaidId == raidId && x.LiebUserId == liebUserId).ToList();
            foreach(RaidSignUp signUp in signUps)
            {
                signUp.GuildWars2AccountId = guildWars2AccountId;
            }
            await context.SaveChangesAsync();
            if(postChanges)
            {
                await _discordService.PostRaidMessage(raidId);
            }
        }

        public async Task ChangeRole(int raidId, ulong liebUserId, int plannedRoleId, SignUpType signUpType, RaidType raidType, bool postChanges = true)
        {
            if (raidType != RaidType.Planned || !IsRoleSignUpAllowed(raidId, liebUserId, plannedRoleId, signUpType, true))
            {
                return;
            }

            using var context = _contextFactory.CreateDbContext();

            List<RaidSignUp> signUps = context.RaidSignUps.Where(x => x.RaidId == raidId && x.LiebUserId == liebUserId).Include(s => s.LiebUser).ToList();

            RaidSignUp? signUp = signUps.FirstOrDefault(x => x.SignUpType != SignUpType.Flex);
            RaidSignUp? flexSignUp = signUps.FirstOrDefault(x => x.SignUpType == SignUpType.Flex && x.RaidRoleId == plannedRoleId);

            //change Flex to current role
            if (flexSignUp != null && signUp != null)
            {
                flexSignUp.RaidRoleId = signUp.RaidRoleId;
            }

            //change to new role
            if (signUp != null)
            {
                signUp.RaidRoleId = plannedRoleId;
                if(!signUp.IsExternalUser)
                {
                    await LogSignUp(signUp, signUp.LiebUser.Name);
                }
            }
            context.SaveChanges();
            if(postChanges)
            {
                await _discordService.PostRaidMessage(raidId);
            }
        }

        public async Task ChangeSignUpType(int raidId, ulong liebUserId, SignUpType signUpType, bool postChanges = true)
        {
            using var context = _contextFactory.CreateDbContext();

            RaidSignUp? signUp = context.RaidSignUps
                                        .Include(s => s.LiebUser)
                                        .FirstOrDefault(x => x.RaidId == raidId && x.LiebUserId == liebUserId 
                                                        && x.SignUpType != SignUpType.Flex);
            
            if (signUp != null && IsRoleSignUpAllowed(raidId, liebUserId, signUp.RaidRoleId, signUpType, true))
            {
                signUp.SignUpType = signUpType;
                await LogSignUp(signUp, signUp.LiebUser.Name);
                context.SaveChanges();
            }
            if(postChanges)
            {
                await _discordService.PostRaidMessage(raidId);
            }
        }

        public bool IsRoleSignUpAllowed(int raidId, ulong liebUserId, int plannedRoleId, SignUpType signUpType, bool moveFlexUser)
        {
            using var context = _contextFactory.CreateDbContext();
            Raid? raid = context.Raids
            .Include(r => r.Roles)
            .Include(r => r.SignUps)
            .FirstOrDefault(r => r.RaidId == raidId);

            if (raid == null) return false;

            if (raid.RaidType == RaidType.Planned)
            {
                if (raid.MoveFlexUsers)
                {
                    //moveFlexUser parameter is for only checking or really moving
                    return IsRoleSignUpAllowedMoveFlex(raid, liebUserId, plannedRoleId, signUpType, moveFlexUser, new List<int>()).Result;
                }
                else
                {
                    return IsRoleSignUpAllowedBasicCheck(liebUserId, plannedRoleId, signUpType);
                }
            }
            else
            {
                return IsRandomRoleSignUpAllowed(raid, liebUserId, signUpType, plannedRoleId);
            }
        }

        private bool IsRoleSignUpAllowedBasicCheck(ulong liebUserId, int plannedRoleId, SignUpType signUpType)
        {
            if(signUpType == SignUpType.Backup || signUpType == SignUpType.Flex || signUpType == SignUpType.SignedOff)
            {
                return true;
            }

            using var context = _contextFactory.CreateDbContext();

            List<RaidSignUp> signUps = context.RaidSignUps.Where(s => s.RaidRoleId == plannedRoleId).ToList();

            RaidRole? role = context.RaidRoles
            .FirstOrDefault(r => r.RaidRoleId == plannedRoleId);

            if (role == null)
                return false;

            if(signUps.Count(s => s.SignUpType == SignUpType.SignedUp) < role.Spots)
                return true;

            return signUps.Where(s => s.LiebUserId == liebUserId && s.SignUpType == SignUpType.SignedUp).Any();
        }

        private async Task<bool> IsRoleSignUpAllowedMoveFlex(Raid raid, ulong liebUserId, int plannedRoleId, SignUpType signUpType, bool moveFlexUser, List<int> checkedRoleIds)
        {
            if (IsRoleSignUpAllowedBasicCheck(liebUserId, plannedRoleId, signUpType))
                return true;

            if (checkedRoleIds == null)
                checkedRoleIds = new List<int>();
            checkedRoleIds.Add(plannedRoleId);

            if (raid == null)
            {
                return false;
            }

            foreach (ulong userId in raid.SignUps.Where(s => s.RaidRoleId == plannedRoleId && s.SignUpType == SignUpType.SignedUp && s.LiebUserId.HasValue).Select(s => s.LiebUserId))
            {
                foreach (RaidSignUp signUp in raid.SignUps.Where(s => s.LiebUserId == userId && s.SignUpType == SignUpType.Flex))
                {
                    if (!checkedRoleIds.Contains(signUp.RaidRoleId)
                        && await IsRoleSignUpAllowedMoveFlex(raid, userId, signUp.RaidRoleId, SignUpType.SignedUp, moveFlexUser, checkedRoleIds))
                    {
                        if (moveFlexUser)
                        {
                            await ChangeRole(raid.RaidId, userId, signUp.RaidRoleId, SignUpType.SignedUp, raid.RaidType, false);
                        }
                        return true;
                    }
                }
            }
            return false;
        }

        public bool IsRandomRoleSignUpAllowed(Raid raid, ulong liebUserId, SignUpType signUpType, int plannedRoleId = 0)
        {
            RaidRole randomRole = raid.Roles.First(r => r.IsRandomSignUpRole);
            int signedUpUsers = raid.SignUps.Where(s => s.SignUpType == SignUpType.SignedUp).Count();
            int randomSpots = randomRole.Spots;
            
            if(raid.SignUps.Where(s => s.LiebUserId == liebUserId).Any())
            {
                int userRoleId = raid.SignUps.First(s => s.LiebUserId == liebUserId).RaidRoleId;
                if(plannedRoleId != 0 && plannedRoleId != userRoleId) return false;
            }
            else
            {
                if(plannedRoleId != 0 && plannedRoleId != randomRole.RaidRoleId) return false;
            }

            if(randomSpots - signedUpUsers > 0) return true;

            if(signUpType == SignUpType.Backup) return true;

            if(raid.SignUps.Where(s => s.LiebUserId == liebUserId).Any())
            {
                return raid.SignUps.First(s => s.LiebUserId == liebUserId).SignUpType == SignUpType.SignedUp;
            }
            return false;
        }

        public bool IsRaidSignUpAllowed(ulong liebUserId, int raidId, out string errorMessage, bool ignoreRole = false)
        {
            errorMessage = string.Empty;
            using var context = _contextFactory.CreateDbContext();
            Raid? raid = context.Raids
                .AsNoTracking()
                .FirstOrDefault(r => r.RaidId == raidId);
            if(raid == null)
            {
                errorMessage = "Raid not found.";
                return false;
            }
            LiebUser? user = context.LiebUsers
                .Include(u => u.RoleAssignments)
                .ThenInclude(a => a.LiebRole)
                .Include(u => u.GuildWars2Accounts)
                .ThenInclude(a => a.EquippedBuilds)
                .ThenInclude(b => b.GuildWars2Build)
                .AsNoTracking()
                .FirstOrDefault(r => r.Id == liebUserId);
            if (user == null)
            {
                errorMessage = "User not found.";
                return false;
            }

            if (user.GuildWars2Accounts.Count == 0)
            {
                errorMessage = "No Guild Wars 2 account found.";
                return false;
            }

            if (raid.RaidType != RaidType.Planned && !user.GuildWars2Accounts.Where(a => a.EquippedBuilds.Where(b => b.GuildWars2Build.UseInRandomRaid).Count() > 0).Any())
            {
                errorMessage = "No equipped Guild Wars 2 build found.";
                return false;
            }

            if (!ignoreRole && !string.IsNullOrEmpty(raid.RequiredRole) 
                && !user.RoleAssignments.Where(a => a.LiebRole.RoleName == raid.RequiredRole).Any() 
                && raid.FreeForAllTimeUTC.UtcDateTime > DateTimeOffset.UtcNow)
            {
                bool userHasRole = user.RoleAssignments.Where(a => a.LiebRole.RoleName == raid.RequiredRole).Any();
                errorMessage = $"The raid is still locked for {raid.RequiredRole}.";
                return false;
            }

            if(raid.EndTimeUTC < DateTimeOffset.UtcNow)
            {
                errorMessage = $"The raid already ended.";
                return false;
            }

            if(user.BannedUntil > DateTimeOffset.UtcNow)
            {
                errorMessage = $"You are banned until {user.BannedUntil}.";
                return false;
            }

            return true;
        }

        public bool IsExternalSignUpAllowed(int raidId, out string errorMessage)
        {
            errorMessage = string.Empty;
            using var context = _contextFactory.CreateDbContext();
            Raid? raid = context.Raids
                .AsNoTracking()
                .FirstOrDefault(r => r.RaidId == raidId);
            if(raid == null)
            {
                errorMessage = "Raid not found.";
                return false;
            }

            if (raid.RaidType != RaidType.Planned)
            {
                errorMessage = "Random raids need an Account with equipped builds.";
                return false;
            }

            if(raid.EndTimeUTC < DateTimeOffset.UtcNow)
            {
                errorMessage = $"The raid already ended.";
                return false;
            }

            return true;
        }

        public bool IsRaidSlashCommandAllowed(ulong liebUserId, out string errorMessage)
        {
            errorMessage = string.Empty;

            using var context = _contextFactory.CreateDbContext();
            LiebUser user = context.LiebUsers
                                .Include(u => u.RoleAssignments)
                                .ThenInclude(a => a.LiebRole)
                                .FirstOrDefault(u => u.Id == liebUserId);
            if (user != null && user.RoleAssignments.Max(a => a.LiebRole.Level) >= Constants.Roles.RaidLead.PowerLevel)
            {
                return true;
            }
            errorMessage = "insufficient permissions";
            return false;
        }

        private async Task LogSignUp(RaidSignUp signUp, string userName, ulong signedUpBy = 0)
        {
            _ = SendDiscordSignUpLogMessage(signUp, userName, signedUpBy);
        }

        public async Task SendDiscordSignUpLogMessage(RaidSignUp signUp, string userName, ulong signedUpBy = 0)
        {
            using var context = _contextFactory.CreateDbContext();

            Raid raid = context.Raids
                .Include(r => r.DiscordRaidMessages)
                .FirstOrDefault(r => r.RaidId == signUp.RaidId);

            if(raid == null) return;

            if(raid.DiscordRaidMessages.Count > 0)
            {
                string signedUpByUserName = userName;
                if(signedUpBy > 0)
                {
                    LiebUser signedUpByUser = context.LiebUsers
                        .FirstOrDefault(u => u.Id == signedUpBy);

                    if(signedUpByUser != null)
                        signedUpByUserName = signedUpByUser.Name;
                    else
                        signedUpByUserName = "user not found";
                }

                string message = $"{signedUpByUserName} signed up {userName} as {signUp.SignUpType.ToString()}";
                HashSet<ulong> guildIds = raid.DiscordRaidMessages.Select(m => m.DiscordGuildId).ToHashSet();
                foreach(ulong guildId in guildIds)
                {
                    DiscordSettings settings = _discordService.GetDiscordSettings(guildId);
                    if(settings.DiscordLogChannel > 0)
                    {
                        await _discordService.SendChannelMessage(guildId, settings.DiscordLogChannel, message, raid.Title);
                    }
                }
            }
        }

        public async Task SendReminders()
        {
            using var context = _contextFactory.CreateDbContext();
            List<RaidReminder> reminders = context.RaidReminders
                .Where(r => !r.Sent)
                .ToList();

            DateTimeOffset utcNow = DateTimeOffset.UtcNow;
            foreach(RaidReminder reminder in reminders.Where(r => r.ReminderTimeUTC < utcNow))
            {
                Raid raid = context.Raids
                    .Include(r => r.SignUps)
                    .Include(r => r.Reminders)
                    .First(r => r.Reminders.Where(re => re.RaidReminderId == reminder.RaidReminderId).Any());
                switch(reminder.Type)
                {
                    case RaidReminder.ReminderType.User:
                        await _discordService.SendUserReminder(reminder, raid);
                        break;
                    case RaidReminder.ReminderType.Channel:
                        await _discordService.SendChannelReminder(reminder, raid.Title);
                        break;
                    case RaidReminder.ReminderType.Group:
                        await _discordService.SendGroupReminder(reminder, raid);
                        break;
                }
            }
        }

        public RaidRole CreateRandomSignUpRole(RaidType raidType, int spots = 10)
        {
            return new RaidRole()
                {
                    Spots = spots,
                    Name = "Random",
                    Description = raidType.ToString(),
                    IsRandomSignUpRole = true
                };
        }

        public async Task RemoveMaybes()
        {
            using var context = _contextFactory.CreateDbContext();
            List<Raid> raids = context.Raids.Include(r => r.SignUps).ToList();
            foreach(Raid raid in raids.Where(r => r.StartTimeUTC < DateTimeOffset.UtcNow.AddMinutes(Constants.REMOVE_MAYBE_MINUTES)
                                                && r.SignUps.Where(s => s.SignUpType == SignUpType.Maybe).Any()))
            {
                foreach(RaidSignUp signup in raid.SignUps)
                {
                    if(signup.SignUpType == SignUpType.Maybe && signup.LiebUserId.HasValue)
                    {
                        await SignOff(raid.RaidId, signup.LiebUserId.Value);
                    }
                }
            }
        }

        public async Task CleanUpRaids()
        {
            using var context = _contextFactory.CreateDbContext();
            List<Raid> raids = GetRaids();

            DateTimeOffset utcNow = DateTimeOffset.UtcNow;
            foreach(Raid raid in raids.Where(r => r.EndTimeUTC < utcNow.AddYears(-1)))
            {
                await DeleteRaid(raid.RaidId, null);
            }
            foreach(Raid raid in raids.Where(r => r.EndTimeUTC < utcNow.AddHours(-1) 
                                                && (r.DiscordRaidMessages.Count > 0 || r.Reminders.Count > 0)))
            {
                await _discordService.DeleteRaidMessages(raid);
                context.RaidReminders.RemoveRange(raid.Reminders);
                context.DiscordRaidMessages.RemoveRange(raid.DiscordRaidMessages);
                await context.SaveChangesAsync();
            }
        }
    }
}