using AutoMapper;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using PARR.API.Contracts.V1;
using PARR.API.Contracts.V1.Requests.Queries;
using PARR.API.Contracts.V1.Responses;
using PARR.API.Contracts.V1.Responses.Base;
using PARR.API.Contracts.V1.Responses.Statistics;
using PARR.API.Controllers.V1.Base;
using PARR.API.Services.Interfaces;
using PARR.DAL.Models;
using PARR.DAL.Services.Interfaces;

namespace PARR.API.Controllers.V1.Statistics
{
    /// <summary>
    /// Статистика загрузки регламентными работами по Видам работ(works)
    /// </summary>
    public class StatWorkWorkLoadController : BaseApiController
    {
        private readonly ITemplateService templateService;
        private readonly IWorkLoadService workLoadService;
        private readonly IMapper mapper;

        public StatWorkWorkLoadController(
                ITemplateService templateService,
                IWorkLoadService workLoadService,
                IMapper mapper
            )
        {
            this.templateService = templateService;
            this.workLoadService = workLoadService;
            this.mapper = mapper;
        }


        /// <summary>
        /// Статистика загрузки регламентными работами по Видам работ(works)
        /// </summary>
        /// <param name="workGroupId"></param>
        /// <param name="requestQuery"></param>
        /// <returns></returns>
        [HttpGet(ApiRoutes.StatWorkWorkLoad.Get)]
        public async Task<IActionResult> Get([FromRoute] Guid workGroupId, [FromQuery] WorkloadBaseQuery requestQuery)
        {
            var daysList = workLoadService.GetDatesForPeriod(requestQuery);

            IQueryable<Template> query = templateService.Get()
                                            .Include(t => t.Host);

            query = workLoadService.FilterTemplatesQuery(query, requestQuery).Where(t => t.Host!.WorkGroupId == workGroupId);

            var groupedQuery = query.GroupBy(t => new { t.NextRun.DateTime.Date, t.ApplicationInWorkId })
                                    .Select(t => new
                                    {
                                        ApplicationInWorkId = t.Key.ApplicationInWorkId,
                                        Date = t.Key.Date,
                                        TemplateCount = t.Count()
                                    });

            var queryResult = await groupedQuery.ToListAsync();


            // получаем только работы по которым есть шаблоны (активированные/деакт) и за любой период
            var allAppInWorks = await templateService.Get()
                                                    .Include(t => t.Host)
                                                    .Include(t => t.ApplicationsInWork).ThenInclude(t => t.Application).ThenInclude(t => t.ApplicationType)
                                                    .Where(t => t.Host.WorkGroupId == workGroupId)
                                                    .Select(t => t.ApplicationsInWork)
                                                    .Distinct()
                                                    .ToListAsync();

            var response = new List<StatWorkWorkLoadResponse>();

            allAppInWorks.ForEach(appInWork =>
            {
                var workLoads = daysList.Select(t => new StatWorkLoadDataResponse
                {
                    Date = t,
                    TemplateCount = queryResult.FirstOrDefault(x => x.ApplicationInWorkId == appInWork.Id && x.Date.Date == t.Date)?.TemplateCount ?? 0
                }).OrderBy(t => t.Date).ToList();

                response.Add(new StatWorkWorkLoadResponse
                {
                    Job = mapper.Map<ApplicationInWorkBaseResponse>(appInWork),
                    WorkLoad = workLoads
                });
            });

            response = response.OrderBy(t => t.Job.ShortDescription).ThenBy(t=>t.Job.Application?.Name).ToList();

            return Ok(new Response<List<StatWorkWorkLoadResponse>>(response, true));
        }
    }
}