FinalPresenceLexa/data/Repository/SQLPresenceRepository.cs

using data.RemoteData.RemoteDataBase.DAO;
using data.RemoteData.RemoteDataBase;
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using System.Linq;

namespace data.Repository
{
    public class SQLPresenceRepositoryImpl : IPresenceRepository
    {
        private readonly RemoteDatabaseContext _remoteDatabaseContext;

        public SQLPresenceRepositoryImpl(RemoteDatabaseContext remoteDatabaseContext)
        {
            _remoteDatabaseContext = remoteDatabaseContext;
        }

        public List<PresenceDAO> GetAttendanceByGroup(int groupId)
        {
            return _remoteDatabaseContext.Presences
                .Where(p => p.GroupId == groupId)
                .ToList();
        }

        public List<PresenceDAO> GetPresenceForAbsent(DateOnly date, int groupId)
        {
            return _remoteDatabaseContext.Presences
                .Where(p => p.GroupId == groupId && p.Date == date && !p.IsAttendance)
                .ToList();
        }

        public List<PresenceDAO> GetPresenceByDateAndGroup(DateOnly startDate, DateOnly endDate, int groupId)
        {
            return _remoteDatabaseContext.Presences
                .Where(p => p.Date >= startDate && p.Date <= endDate && p.GroupId == groupId)
                .ToList();
        }

        public List<PresenceDAO> GetPresenceByGroup(int groupId)
        {
            return _remoteDatabaseContext.Presences
                .Where(p => p.GroupId == groupId)
                .OrderBy(p => p.Date)
                .ThenBy(p => p.UserId)
                .ToList();
        }

        public void SavePresence(List<PresenceDAO> presences)
        {
            _remoteDatabaseContext.Presences.AddRange(presences);
            _remoteDatabaseContext.SaveChanges();
        }

        public void UpdateAtt(int userId, int groupId, int firstLesson, int lastLesson, DateOnly date, bool isAttendance)
        {
            var presences = _remoteDatabaseContext.Presences
                .Where(p => p.UserId == userId && 
                           p.GroupId == groupId && 
                           p.LessonNumber >= firstLesson && 
                           p.LessonNumber <= lastLesson && 
                           p.Date == date)
                .ToList();

            foreach (var presence in presences)
            {
                presence.IsAttendance = isAttendance;
            }

            _remoteDatabaseContext.SaveChanges();
        }

        public DateOnly? GetLastDateByGroupId(int groupId)
        {
            return _remoteDatabaseContext.Presences
                .Where(p => p.GroupId == groupId)
                .Max(p => (DateOnly?)p.Date);
        }

        public List<PresenceDAO> PresenceSort(List<PresenceDAO> presences)
        {
            return presences.OrderBy(p => p.Date).ToList();
        }

        public GroupAttendanceStatistics GetGeneralPresenceForGroup(int groupId)
        {
            var presences = _remoteDatabaseContext.Presences
                .Where(p => p.GroupId == groupId)
                .ToList();

            var dates = presences.Select(p => p.Date).Distinct().ToList();
            var users = presences.Select(p => p.UserId).Distinct().ToList();

            var statistics = new GroupAttendanceStatistics
            {
                UserCount = users.Count,
                TotalLessons = presences.Count / users.Count,
                AttendancePercentage = (double)presences.Count(p => p.IsAttendance) / presences.Count * 100
            };

            foreach (var userId in users)
            {
                var userPresences = presences.Where(p => p.UserId == userId).ToList();
                statistics.UserAttendanceDetails.Add(new UserAttendance
                {
                    UserId = userId,
                    Attended = userPresences.Count(p => p.IsAttendance),
                    Missed = userPresences.Count(p => !p.IsAttendance)
                });
            }

            return statistics;
        }

        public List<AllPresence> AllPresence(int groupId, DateOnly? dateStart, DateOnly? dateEnd, int? userId)
        {
            var query = _remoteDatabaseContext.Presences
                .Where(p => p.GroupId == groupId);

            if (dateStart.HasValue && dateEnd.HasValue)
                query = query.Where(p => p.Date >= dateStart && p.Date <= dateEnd);
            
            if (userId.HasValue)
                query = query.Where(p => p.UserId == userId);

            return query.Select(p => new AllPresence
            {
                GroupName = _remoteDatabaseContext.Groups.First(g => g.Id == p.GroupId).Name,
                Users = new UserPresence()
                {
                    FIO = _remoteDatabaseContext.Users.First(u => u.UserId == p.UserId).FIO,
                    LessonNumber = p.LessonNumber,
                    Date = p.Date,
                    isAttendance = p.IsAttendance
                }
            }).ToList();
        }

        public void UpdateAttendance(List<AttendanceInput> attendanceList)
        {
            foreach (var attendance in attendanceList)
            {
                var existing = _remoteDatabaseContext.Presences.FirstOrDefault(p =>
                    p.GroupId == attendance.GroupId && 
                    p.UserId == attendance.UserId && 
                    p.Date == attendance.Date && 
                    p.LessonNumber == attendance.LessonNumber);

                if (existing != null)
                {
                    existing.IsAttendance = attendance.IsAttendance;
                }
                else
                {
                    _remoteDatabaseContext.Presences.Add(new PresenceDAO
                    {
                        GroupId = attendance.GroupId,
                        UserId = attendance.UserId,
                        Date = attendance.Date,
                        LessonNumber = attendance.LessonNumber,
                        IsAttendance = attendance.IsAttendance
                    });
                }
            }

            _remoteDatabaseContext.SaveChanges();
        }

        public void DeletePresenceByUser(int userId)
        {
            var records = _remoteDatabaseContext.Presences
                .Where(p => p.UserId == userId)
                .ToList();

            _remoteDatabaseContext.Presences.RemoveRange(records);
            _remoteDatabaseContext.SaveChanges();
        }

        public void DeletePresenceByDateRange(int groupId, DateOnly startDate, DateOnly endDate)
        {
            var records = _remoteDatabaseContext.Presences
                .Where(p => p.GroupId == groupId && p.Date >= startDate && p.Date <= endDate)
                .ToList();

            _remoteDatabaseContext.Presences.RemoveRange(records);
            _remoteDatabaseContext.SaveChanges();
        }

        public void DeletePresenceByGroup(int groupId)
        {
            var records = _remoteDatabaseContext.Presences
                .Where(p => p.GroupId == groupId)
                .ToList();

            _remoteDatabaseContext.Presences.RemoveRange(records);
            _remoteDatabaseContext.SaveChanges();
        }

        public List<PresenceDAO> GetPresenceByUserAndGroup(int userId, int groupId)
        {
            return _remoteDatabaseContext.Presences
                .Where(p => p.UserId == userId && p.GroupId == groupId)
                .ToList();
        }

        public List<PresenceDAO> GetPresenceByDateRange(int groupId, DateOnly startDate, DateOnly endDate)
        {
            return _remoteDatabaseContext.Presences
                .Where(p => p.GroupId == groupId && p.Date >= startDate && p.Date <= endDate)
                .ToList();
        }

        public void UpdateAttendance(int userId, int groupId, DateOnly date, int lessonNumber, bool isAttendance)
        {
            var record = _remoteDatabaseContext.Presences.FirstOrDefault(p =>
                p.UserId == userId &&
                p.GroupId == groupId &&
                p.Date == date &&
                p.LessonNumber == lessonNumber);

            if (record != null)
            {
                record.IsAttendance = isAttendance;
                _remoteDatabaseContext.SaveChanges();
            }
        }

        public List<PresenceDAO> GetPresence(int groupId, DateOnly? date, int? userId)
        {
            var query = _remoteDatabaseContext.Presences.Where(p => p.GroupId == groupId);

            if (date.HasValue)
                query = query.Where(p => p.Date == date.Value);

            if (userId.HasValue)
                query = query.Where(p => p.UserId == userId.Value);

            return query.ToList();
        }

        public void ClearPresenceByGroup(int groupId)
        {
            var records = _remoteDatabaseContext.Presences
                .Where(p => p.GroupId == groupId)
                .ToList();

            _remoteDatabaseContext.Presences.RemoveRange(records);
            _remoteDatabaseContext.SaveChanges();
        }

        public void AddPresence(List<PresenceDAO> presenceList)
        {
            _remoteDatabaseContext.Presences.AddRange(presenceList);
            _remoteDatabaseContext.SaveChanges();
        }

        public void UpdatePresence(List<PresenceDAO> updatedList)
        {
            foreach (var item in updatedList)
            {
                var existing = _remoteDatabaseContext.Presences.FirstOrDefault(p =>
                    p.Date == item.Date &&
                    p.UserId == item.UserId &&
                    p.LessonNumber == item.LessonNumber);

                if (existing != null)
                {
                    existing.IsAttendance = item.IsAttendance;
                }
            }

            _remoteDatabaseContext.SaveChanges();
        }

        public List<PresenceDAO> GetPresenceByUserId(int userId)
        {
            var query = _remoteDatabaseContext.Presences.Where(p => p.UserId == userId);
            
            return query.ToList();
        }
    }
}