/Gradebook.Data/Repositories/GradeRepository.cs

using System.Collections.Generic;

using Gradebook.Contracts.Repositories;

using Gradebook.Model;

using System;

using System.Data.Entity;

using System.Linq;



namespace Gradebook.Data.Repositories

{

    public class GradeRepository : RepositoryBase<Grade>, IGradeRepository

    {

        public GradeRepository(DbContext dbContext) : base(dbContext) { }



        public int GetAverageByTask(int taskId)

        {

            if (!DbContext.Set<Task>().Any(x => x.Id == taskId))

                throw new ArgumentException("taskId");



            if (!DbSet.Any(x => x.TaskId == taskId)) return 0;



            return (int)Math.Round(DbSet.Where(x => x.TaskId == taskId).Average(x => x.Value));

        }



        public int GetRate(int taskId, int studentId)

        {

            if (!DbContext.Set<Task>().Any(x => x.Id == taskId))

                throw new ArgumentException("taskId");

            if (!DbContext.Set<Student>().Any(x => x.Id == studentId))

                throw new ArgumentException("studentId");

            if (!Contains(taskId, studentId))

                throw new ArgumentException();



            var total = DbContext.Set<Task>().Single(x => x.Id == taskId).TotalMarks;

            var grade = DbSet.Single(x => x.TaskId == taskId && x.StudentId == studentId).Value;

            var rank = (int)Math.Round((double)grade * 100 / total);



            return rank;

        }



        public int GetValue(int taskId, int studentId)

        {

            if (!Contains(taskId, studentId)) return 0;



            return Read(taskId, studentId).Value;

        }



        public int GetRank(int taskId, int studentId)

        {

            if (!DbContext.Set<Task>().Any(x => x.Id == taskId))

                throw new ArgumentException("taskId");

            if (!DbContext.Set<Student>().Any(x => x.Id == studentId))

                throw new ArgumentException("studentId");

            if (!Contains(taskId, studentId))

                throw new ArgumentException();



            var grade = DbSet.Single(x => x.TaskId == taskId && x.StudentId == studentId);



            return DbSet.Where(x => x.TaskId == taskId)

                        .OrderBy(x => x.Value)

                        .ToList()

                        .IndexOf(grade) + 1;

        }



        public IEnumerable<Grade> GetByTask(int taskId)

        {

            if (!DbContext.Set<Task>().Any(x => x.Id == taskId))

                throw new ArgumentException("taskId");



            return DbSet.Include(x => x.Student).Where(x => x.TaskId == taskId);

        }



        public IEnumerable<Grade> GetAllByTask(int taskId)

        {

            if (!DbContext.Set<Task>().Any(x => x.Id == taskId))

                throw new ArgumentException("taskId");



            var students = DbContext.Set<Task>().Include(x => x.Code).Include(x => x.Code.TeacherClassCodes)

                                    .Where(x => x.Id == taskId)

                                    .Select(x => x.Code)

                                    .SelectMany(x => x.TeacherClassCodes)

                                    .SelectMany(x => x.StudentClassCodes)

                                    .Select(x => x.Student)

                                    .ToList();



            foreach (var student in students)

            {

                if (Contains(taskId, student.Id))

                {

                    yield return DbSet.Include(x => x.Task.Type).Include(x => x.Task.Code.TeacherClassCodes)

                                      .Single(x => x.TaskId == taskId && x.StudentId == student.Id);

                }

                else

                {

                    yield return new Grade

                        {

                            TaskId = taskId,

                            StudentId = student.Id,

                            Student = student,

                            Task = DbContext.Set<Task>().Include(x => x.Type).Include(x => x.Code.TeacherClassCodes).Single(x => x.Id == taskId)

                        };

                }

            }

        }



        public IEnumerable<Grade> GetByClassCode(int codeId, int termId = 0)

        {

            if (!DbContext.Set<Class>().Any(x => x.Id == codeId))

                throw new ArgumentException("codeId");



            var grades = DbSet.Include(x => x.Student)

                              .Include(x => x.Task.Type)

                              .Include(x => x.Task.Code.TeacherClassCodes)

                              .Where(x => x.Task.CodeId == codeId);



            if (termId != 0)

            {

                grades = grades.Where(x => x.Task.Code.TeacherClassCodes.Any(y => y.TermId == termId));

            }



            return grades;

        }



        public IEnumerable<Grade> GetAllByClassCode(int codeId, int termId = 0, int typeId = 0)

        {

            if (!DbContext.Set<Class>().Any(x => x.Id == codeId))

                throw new ArgumentException("codeId");



            var tasks = DbContext.Set<Task>().Include(x => x.Code.TeacherClassCodes).Where(x => x.CodeId == codeId);



            if (termId != 0)

            {

                tasks = tasks.Where(x => x.Code.TeacherClassCodes.Any(y => y.TermId == termId));

            }



            if (typeId != 0)

            {

                tasks = tasks.Where(x => x.TypeId == typeId);

            }



            var grades = new List<Grade>();



            foreach (var id in tasks.Select(x => x.Id).ToList())

            {

                grades.AddRange(GetAllByTask(id));

            }



            return grades;

        }



        public IEnumerable<Grade> GetAllByStudent(int studentId, int classId = 0)

        {

            return classId == 0

                ? DbSet.Include(x => x.Task.Type).Include(x => x.Student).Where(x => x.StudentId == studentId)

                : GetAllByClassCode(classId).Where(x => x.StudentId == studentId);

        }



        public Grade Create(int taskId, int studentId, int value, string comments = null)

        {

            if (Contains(taskId, studentId))

                throw new ArgumentException();



            if (!DbContext.Set<Task>().Any(x => x.Id == taskId))

                throw new ArgumentException("taskId");



            if (!DbContext.Set<Student>().Any(x => x.Id == taskId))

                throw new ArgumentException("studentId");



            if (DbContext.Set<Task>().Single(x => x.Id == taskId).TotalMarks < value || value < 0)

                throw new ArgumentOutOfRangeException("value");



            return DbSet.Add(new Grade { TaskId = taskId, StudentId = studentId, Value = value, Comments = comments });

        }



        public Grade Read(int taskId, int studentId)

        {

            if (!Contains(taskId, studentId))

                throw new ArgumentException();



            return DbSet.Single(x => x.TaskId == taskId && x.StudentId == studentId);

        }



        public bool Contains(int taskId, int studentId)

        {

            return DbSet.Any(x => x.TaskId == taskId && x.StudentId == studentId);

        }



        public override IQueryable<Grade> GetAll()

        {

            return DbSet.Include(x => x.Student);

        }

    }

}