using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using ESGI.BL.Core;
using ESGI.BL.Core.Validation;
using ESGI.DAL.Core;
using ESGI.DAL.Core.Extensions;
using ESGI.SchoolYears.DAL;
using ESGI.SchoolYears.DAL.Repositories;
using ESGI.ServiceCore.Commands;
using TsyCreator = ESGI.SchoolYears.Workflows.TeacherSchoolYears.Create.IWorkflow;

namespace ESGI.SchoolYears.Commands.UserJoinedToSchool
{
    public class InModel
    {
        public int SchoolID;
        public int UserID;
        public int GlobalSchoolYearID;
        public char UserType;
        public int? TrackID { get; set; }
        public int? MaxStudents { get; set; }
    }

    public class OutModel
    {
        public List<TeacherSchoolYear> TeacherSchoolYears { get; set; }
    }

    public interface ICommand : ICommand<InModel, OutModel>
    {

    }

    public class Command : AsyncCommand<InModel, OutModel>, ICommand
    {
        private readonly ISchoolYearRepository _schoolYearsRepository;
        private readonly ITeacherSchoolYearRepository _teacherSchoolYearRepository;
        private readonly ITracksToSchoolRepository _trackToSchoolRepository;
        private readonly TsyCreator _tsyCreator;
        private Idle<List<SchoolYear>> _schoolYears;
        private Idle<List<TrackToSchoolModel>> _trackToSchool;

        public Command(IUnitOfWork unitOfWork, ISchoolYearRepository schoolYears,
            ITeacherSchoolYearRepository teacherSchoolYearRepository, ITracksToSchoolRepository trackToSchoolRepository, TsyCreator tsyCreator) : base(unitOfWork)
        {
            _schoolYearsRepository = schoolYears;
            _teacherSchoolYearRepository = teacherSchoolYearRepository;
            _trackToSchoolRepository = trackToSchoolRepository;
            _tsyCreator = tsyCreator;
        }

        protected override async Task<OutModel> Execute(InModel model, ICommandContext context)
        {
            var schoolYears = await _schoolYears;
            var modelBuilder = _tsyCreator.ModelBuilder.WithUser(model.UserID).WithUserType(model.UserType);

            string currentYearTrackName = null;
            var result = schoolYears
                .GroupJoin(await _trackToSchool, schoolYear => schoolYear.GlobalSchoolYearID,
                    schoolModel => schoolModel.GlobalSchoolYearId, (schoolYear, trackToSchoolModels) =>
                    {
                        TrackToSchoolModel ts;
                        if (schoolYear.GlobalSchoolYearID == model.GlobalSchoolYearID)
                        {
                            ts = trackToSchoolModels.FirstOrDefault(ttsm => model.TrackID == null || ttsm.TrackId == model.TrackID.Value);
                            currentYearTrackName = ts?.TrackName;
                        }
                        else
                        {
                            ts = trackToSchoolModels.FirstOrDefault(m => currentYearTrackName == null || m.TrackName == currentYearTrackName);
                            if (ts == null)
                            {
                                ts = trackToSchoolModels.FirstOrDefault();
                            }
                        }

                        var wfmodel = modelBuilder.WithSchoolYear(schoolYear).WithTrackToSchool(ts?.TracksToSchool).WithMaxStudents(model.MaxStudents).Build();
                        var resultModel = _tsyCreator.Flow(wfmodel, context).Result;
                        return resultModel.TeacherSchoolYear;
                    }).ToList();

            return new OutModel
            {
                TeacherSchoolYears = result
            };
        }

        protected override Task Validate(InModel model, ICommandContext context)
        {
            // for prevent shown error in exceptionless.
            if (model.UserType != 'T')
                throw new UserFriendlyValidationException("User must be a teacher to create a Teacher school year");

            return Task.CompletedTask;
        }

        protected override Task Init(InModel model, ICommandContext context)
        {
            var usedSys = Idle.From(() =>
            {
                return _teacherSchoolYearRepository.ByUserID(model.UserID)
                    .NotDeleted
                    .Select(t => t.TeacherSchoolYear.SchoolYearID)
                    .ToListAsync();
            });

            _schoolYears = Idle.From(async () =>
            {
                var tsys = await usedSys;
                return await _schoolYearsRepository.BySchoolID(model.SchoolID).Where(s => !tsys.Contains(s.SchoolYear.SchoolYearID) && s.SchoolYear.GlobalSchoolYearID >= model.GlobalSchoolYearID)
                    .Select(s => s.SchoolYear)
                    .OrderBy(s => s.GlobalSchoolYearID)
                    .ToListAsync(context.CancellationToken);
            });

            _trackToSchool = Idle.From(() =>
            {
                if (model.SchoolID == 0)
                {
                    return Task.FromResult(new List<TrackToSchoolModel>());
                }

                return _trackToSchoolRepository
                    .BySchoolID(model.SchoolID)
                    .Where(s => s.Track.GlobalSchoolYear.GlobalSchoolYearID >= model.GlobalSchoolYearID)
                    .Select(s => new TrackToSchoolModel
                    {
                        GlobalSchoolYearId = s.Track.GlobalSchoolYearID,
                        TracksToSchool = s.TracksToSchool,
                        TrackId = s.Track.TrackID,
                        TrackName = s.Track.Name,
                    })
                    .ToListAsync();
            });

            return Task.CompletedTask;
        }


        private class TrackToSchoolModel
        {
            public int TrackId { get; set; }
            public string TrackName { get; set; }
            public int? GlobalSchoolYearId { get; set; }
            public TracksToSchool TracksToSchool { get; set; }
        }
    }
}