using _0_Framework.Application;
using _0_Framework.Domain.CustomizeCheckoutShared.Enums;
using CompanyManagment.App.Contracts.RollCall;
using CompanyManagment.App.Contracts.RollCallEmployeeStatus;
using CompanyManagment.App.Contracts.RollCallService;
using WorkFlow.Application.Contracts.Shared;

namespace WorkFlow.Infrastructure.ACL.RollCall;

public class WorkFlowRollCallACL : IWorkFlowRollCallACL
{
    private readonly IRollCallApplication _rollCallApplication;
    private readonly IRollCallEmployeeStatusApplication _rollCallEmployeeStatusApplication;
    private readonly IRollCallServiceApplication _rollCallServiceApplication;
    public WorkFlowRollCallACL(IRollCallApplication rollCallApplication, IRollCallEmployeeStatusApplication rollCallEmployeeStatusApplication, IRollCallServiceApplication rollCallServiceApplication)
    {
        _rollCallApplication = rollCallApplication;
        _rollCallEmployeeStatusApplication = rollCallEmployeeStatusApplication;
        _rollCallServiceApplication = rollCallServiceApplication;
    }


    public int GetCountCutRollCallByBgService(long workshopId)
    {
        var now = DateTime.Now;

        DateTime.Now.Date.AddMonthsFa(-2, out var twoMonthsAgo);

        return GetRollCallWorkFlowsCutByBgService(workshopId, twoMonthsAgo, now).Count;
    }

    public int GetRollCallAbsentsWorkFlowsCount(long workshopId, DateTime durationEnd, DateTime durationStart)
    {
        return GetAbsentRollCallWorkFlows(workshopId, durationStart, durationEnd).Count;
    }
    public List<(long EmployeeId, string EmployeeName, DateTime startActive, DateTime endActive)> GetActiveWorkshopRollCallEmployees(long workshopId, DateTime start, DateTime end)
    {
        return _rollCallEmployeeStatusApplication.GetActiveByWorkshopIdInDate(workshopId, start, end).Select(x => (x.EmployeeId, x.EmployeeName, x.StartDateGr, x.EndDateGr))
            .ToList();
    }

    public List<DailyRollCallWorkFlowViewModel> GetRollCallWorkFlowsCutByBgService(long workshopId, DateTime start, DateTime end)
    {
        return _rollCallApplication.GetRollCallWorkFlowsCutByBgService(workshopId, start, end).Select(x =>
        {
            return new DailyRollCallWorkFlowViewModel()
            {
                DateTime = x.DateGr,
                DateTimeFa = x.DateFa,
                RollCallWorkFlowPerDayViewModels = x.ActiveEmployees.GroupBy(y=>y.EmployeeId).Select(e => new RollCallWorkFlowViewModel()
                {
                    EmployeeId = e.Key,
                    EmployeeName = e.First().EmployeeFullName,
                    TimesList = e.Select(y=>new RollCallWorkFlowTimesViewModel()
                    {
                        RollCallId = y.Id,
                        StartTimeAndEndTimeAsMessage = $"{TimeOnly.FromDateTime(y.StartDate!.Value):HH:mm} الی {TimeOnly.FromDateTime(y.EndDate.Value):HH:mm}"
                    }).ToList(),
                }).ToList(),
                DayOfWeekFa = x.DateGr.DayOfWeek.DayOfWeeKToPersian(),
            };
        }).Where(x => x.RollCallWorkFlowPerDayViewModels.Count > 0).ToList();
    }
    public List<DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel> GetRollCallsOverlappingLeaves(long workshopId, DateTime start, DateTime end)
    {
	    var rollCalls = _rollCallApplication.GetOverlappedRollCallsWithLeaveInDates(workshopId, start, end).Select(x =>
		    new WorkFlowEmployeeWithRollCallOnLeaveViewModel()
		    {
			    EmployeeFullName = x.EmployeeFullName,
			    EmployeeId = x.EmployeeId,
			    RollCallId = x.RollCallId,
			    EndOfOverlapDateFa = x.EndOfOverlapDateFa,
			    EndOfOverlapTime = x.EndOfOverlapTime,
			    LeaveId = x.LeaveId,
			    StartOfOverlapDateFa = x.StartOfOverlapDateFa,
			    StartOfOverlapTime = x.StartOfOverlapTime,
			    EndOfOverlapDateTime = x.EndOfOverlapDateTime,
			    StartOfOverlapDateTime = x.StartOfOverlapDateTime
		    }).GroupBy(x => x.StartOfOverlapDateTime.Date).Select(x => new DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel
	    {
		    DayOfWeek = x.Key.DayOfWeek.DayOfWeeKToPersian(),
		    DateFa = x.Key.ToFarsi(),
		    EmployeesList = x.ToList(),
		    Date = x.Key
	    }).ToList();

	    return rollCalls;
	}
    public List<DailyRollCallWorkFlowViewModel> GetAbsentRollCallWorkFlows(long workshopId, DateTime durationStart, DateTime durationEnd)
    {
        return _rollCallApplication.GetWorkshopAbsentHistory(workshopId, durationStart, durationEnd).Select(x => new DailyRollCallWorkFlowViewModel()
        {
            IsHoliday = x.IsHoliday,
            DateTime = x.DateGr,
            DateTimeFa = x.DateFa,
            DayOfWeekFa = x.DayOfWeekFa,
            IsFriday = x.IsFriday,
            RollCallWorkFlowPerDayViewModels = x.ActiveEmployees.Select(a => new RollCallWorkFlowViewModel()
            {
                EmployeeId = a.EmployeeId,
                EmployeeName = a.EmployeeFullName,
                WorkshopId = a.WorkshopId
            }).ToList()
        }).ToList();


    }
    public List<NotSlicedRollCallWorkFlowViewModel> GetNotSlicedRollCallsByWorkshopId(long workshopId, DateTime durationStart, DateTime durationEnd)
    {
        return _rollCallApplication.GetNotSlicedRollCallsByWorkshopId(workshopId, durationStart, durationEnd)
            .Select(x => new NotSlicedRollCallWorkFlowViewModel()
            {
                EmployeeId = x.EmployeeId,
                EmployeeName = x.EmployeeFullName,
                RollCallDate = x.DateGr,
                RollCallId = x.Id
            }).ToList();
    }


    public RollCallWorkFlowViewModel GetDetails(long rollCallId)
    {
        var entity = _rollCallApplication.GetDetails(rollCallId);
        if (entity == null)
            return null;
        return new RollCallWorkFlowViewModel
        {
            EmployeeId = entity.EmployeeId,
            EmployeeName = entity.EmployeeFullName,
            TimesList =
            [
                new RollCallWorkFlowTimesViewModel()
                {
                    RollCallId =entity.Id
                }
            ],
            RollCallDate = entity.DateGr.Date,
            WorkshopId = entity.WorkshopId
        };
    }
    public RollCallServiceViewModel GetActiveServiceByWorkshopId(long workshopId)
    {
        return _rollCallServiceApplication.GetActiveServiceByWorkshopId(workshopId);
    }
    public List<DailyRollCallWorkFlowViewModel> GetUndefinedRollCalls(long workshopId, DateTime durationStart, DateTime durationEnd)
    {
        var result = _rollCallApplication.GetUndefinedRollCallWorkFlowsService(workshopId, durationStart, durationEnd).Select(x =>
        {
            return new DailyRollCallWorkFlowViewModel()
            {
                DateTime = x.DateGr,
                DateTimeFa = x.DateFa,
                RollCallWorkFlowPerDayViewModels = x.ActiveEmployees.Select(e => new RollCallWorkFlowViewModel()
                {
                    EmployeeId = e.EmployeeId,
                    EmployeeName = e.EmployeeFullName,
                    //Message = $"{TimeOnly.FromDateTime(e.StartDate!.Value):HH:mm} الی {TimeOnly.FromDateTime(e.EndDate.Value):HH:mm}",
                    TimesList =
                    [
                        new RollCallWorkFlowTimesViewModel()
                        {
                            RollCallId =e.Id
                        }
                    ],
                }).ToList(),
                DayOfWeekFa = x.DayOfWeekFa,
            };
        }).Where(x => x.RollCallWorkFlowPerDayViewModels.Count > 0).ToList();
        return result;
    }
}