using AutoMapper;
using FluentValidation;
using InfluxDB.Client.Api.Domain;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using PARR.API.Contracts.V1;
using PARR.API.Contracts.V1.Requests;
using PARR.API.Contracts.V1.Requests.Queries;
using PARR.API.Contracts.V1.Responses;
using PARR.API.Contracts.V1.Responses.Base;
using PARR.API.Controllers.V1.Base;
using PARR.API.Extensions;
using PARR.API.Services.Interfaces;
using PARR.Constants;
using PARR.DAL.DomainModels;
using PARR.DAL.Models.Job;
using PARR.DAL.Services.Interfaces.Job;
using System.ComponentModel.DataAnnotations;

namespace PARR.API.Controllers.V1
{
    /// <summary>
    /// Управление группами работам
    /// </summary>
    [Authorize(Roles = ParrRoles.Administrator.Role)]
    public class JobGroupController : BaseApiController
    {
        private readonly ILogger<JobController> logger;
        private readonly IMapper mapper;
        private readonly IUriService uriService;
        private readonly IJobGroupService groupService;
        private readonly IValidator<JobGroupRequest> validator;

        public JobGroupController(
            ILogger<JobController> logger,
            IMapper mapper,
            IUriService uriService,
            IJobGroupService groupService,
            IValidator<JobGroupRequest> validator
            )
        {
            this.logger = logger;
            this.mapper = mapper;
            this.uriService = uriService;
            this.groupService = groupService;
            this.validator = validator;
        }


        /// <summary>
        /// Получить список групп заданий на выполнение работ постранично
        /// </summary>
        /// <returns></returns>
        [HttpGet(ApiRoutes.JobGroup.GetAll)]
        public async Task<IActionResult> GetAll([FromQuery] PaginationQuery paginationQuery, [FromQuery] JobGroupQuery filter)
        {
            var paginationFilter = mapper.Map<PaginationFilter>(paginationQuery);

            IQueryable<JobGroup> query = groupService.Get();

            query = query.OrderBy(t => t.GroupName);

            if (!string.IsNullOrEmpty(filter.Name))
                query = query.Where(t => t.GroupName.ToLower().Contains(filter.Name.ToLower()));

            if (!string.IsNullOrEmpty(filter.ShortDescription))
                query = query.Where(t => t.ShortDescription.ToLower().Contains(filter.ShortDescription.ToLower()));

            if (filter.IsFull)
                query = query.Include(t => t.Jobs).ThenInclude(t => t.Tnk);

            var jobs = await groupService.GetPage(query, paginationFilter).ToListAsync();

            if (!jobs.Any())
                return NoContent();

            if (filter.IsFull == true)
            {
                var responseFull = mapper.Map<List<JobGroupResponse>>(jobs);
                var paginationResponseFull = new PagedResponse<JobGroupResponse>(responseFull, true).GetPaginatedProps(paginationFilter, query);

                return Ok(paginationResponseFull);
            }

            var response = mapper.Map<List<JobGroupBaseResponse>>(jobs);

            var paginationResponse = new PagedResponse<JobGroupBaseResponse>(response, true).GetPaginatedProps(paginationFilter, query);

            return Ok(paginationResponse);
        }


        /// <summary>
        /// Получить группу заданий на выполнение работ по id
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet(ApiRoutes.JobGroup.Get)]
        public async Task<IActionResult> GetById([FromRoute] Guid id)
        {
            var jobGroup = await groupService.Get()
                                        .Include(t => t.Jobs).ThenInclude(t => t.Tnk)
                                        .FirstOrDefaultAsync(t => t.Id == id);

            if (jobGroup == null)
                return NotFound();

            var response = mapper.Map<JobGroupResponse>(jobGroup);

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


        /// <summary>
        /// Создать группу заданий на выполнение работ (JobGroup)
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost(ApiRoutes.JobGroup.Create)]
        public async Task<IActionResult> Create([FromBody] JobGroupRequest request)
        {
            var resultValidate = await validator.ValidateAsync(request);

            if (!resultValidate.IsValid)
                return BadRequest(new Response(resultValidate.Errors));

            var jobGroup = new JobGroup
            {
                Id = Guid.NewGuid(),
                GroupName = request.Name.Trim(),
                IsUmbrella = request.IsUmbrella,
                ShortDescription = request.ShortDescription.Trim(),
                FullDescription = request.FullDescription.Trim(),
                Solution = request.Solution.Trim(),
                TemplateDuration = request.TemplateDuration.Trim(),
                ReferenceDate = request.ReferenceDate,
                IsAutoDistributionEnabled = request.IsAutoDistributionEnabled,
                IsAgent = request.IsAgent,
                AgentName = request.AgentName,
                AgentTimeOutSec = request.AgentTimeOutSec,
                AgentScript = request.AgentScript
            };


            if (!await groupService.CreateAsync(jobGroup) || !await groupService.CommitAsync())
                return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = "Ошибка при создании группы заданий на выполнение работ" } }));

            logger.LogInformation($"Пользователь {User.Identity?.Name} добавил группу заданий на выполнение работ: {jobGroup.Id}, {jobGroup.GroupName}, {jobGroup.ShortDescription}");


            var createdJobGroup = await groupService.Get().Include(t=>t.Jobs).ThenInclude(t => t.Tnk)
                                             .FirstAsync(t => t.Id == jobGroup.Id);

            var locationUri = uriService.GetUri(ApiRoutes.JobGroup.Get, ApiRoutes.JobGroup.getParam, createdJobGroup.Id);

            var response = mapper.Map<JobGroupResponse>(createdJobGroup);

            return Created(locationUri, new Response<JobGroupResponse>(response, true));
        }


        /// <summary>
        /// Обновить группу заданий на выполнение работ (JobGroup)
        /// </summary>
        /// <param name="id"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPut(ApiRoutes.JobGroup.Update)]
        public async Task<IActionResult> Update([FromRoute] Guid id, [FromBody] JobGroupRequest request)
        {
            var resultValidate = await validator.ValidateAsync(request);

            if (!resultValidate.IsValid)
                return BadRequest(new Response(resultValidate.Errors));

            var orig = await groupService.Get()
                                    .Include(t=>t.Jobs)
                                        .ThenInclude(t => t.Tnk)
                                    .FirstOrDefaultAsync(t => t.Id == id);

            if (orig == null)
                return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = $"Ошибка при изменении группы заданий на выполнение работ. Не найдена группа с Id: {id}" } }));

            orig.GroupName = request.Name.Trim();
            orig.IsUmbrella = request.IsUmbrella;
            orig.ShortDescription = request.ShortDescription.Trim();
            orig.FullDescription = request.FullDescription.Trim();
            orig.Solution = request.Solution.Trim();
            orig.TemplateDuration = request.TemplateDuration.Trim();
            orig.ReferenceDate = request.ReferenceDate;
            orig.IsAutoDistributionEnabled = request.IsAutoDistributionEnabled;
            orig.IsAgent = request.IsAgent;
            orig.AgentName = request.AgentName;
            orig.AgentTimeOutSec = request.AgentTimeOutSec;
            orig.AgentScript = request.AgentScript;

            if (!await groupService.CommitAsync())
                return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = "Ошибка при изменении группы заданий на выполнение работ." } }));

            logger.LogInformation($"Пользователь {User.Identity?.Name} обновил группу заданий на выполнение работ: {orig.Id}," +
                $" {orig.GroupName}, {orig.IsUmbrella}, {orig.ShortDescription}, {orig.FullDescription}," +
                $" {orig.Solution}, {orig.TemplateDuration}, {orig.ReferenceDate}, {orig.IsAutoDistributionEnabled}" +
                $", {orig.IsAgent}, {orig.AgentName}, {orig.AgentTimeOutSec}, {orig.AgentScript}");


            var updatedJobGroup = await groupService.Get()
                                                    .Include(t => t.Jobs)
                                                        .ThenInclude(t => t.Tnk)
                                                    .FirstAsync(t => t.Id == orig.Id);

            var response = mapper.Map<JobResponse>(updatedJobGroup);

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


        /// <summary>
        /// Удалить группу заданий на выполнение работ (только если нет связанных шаблонов)
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpDelete(ApiRoutes.JobGroup.Delete)]
        public async Task<IActionResult> Delete([FromRoute] Guid id)
        {
            var jobGroup = await groupService.Get()
                                .Include(t => t.Jobs)
                                    .ThenInclude(t => t.Tnk)
                                .FirstOrDefaultAsync(t => t.Id == id);

            if (jobGroup == null)
                return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel {
                    Message = $"Ошибка при удалении группы заданий на выполнение работ. Не найдена группа заданий на выполнение работ Id: {id}"
                } }));

            if (!groupService.Delete(jobGroup) || !await groupService.CommitAsync())
                return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel {
                    Message = $"Ошибка при удалении группы заданий на выполнение работ"
                } }));

            logger.LogInformation($"Пользователь {User.Identity?.Name} удалил задание на выполнение работ: {jobGroup.Id},{jobGroup.GroupName}," +
                $" {jobGroup.IsUmbrella}, {jobGroup.ShortDescription}, {jobGroup.FullDescription}," +
                $" {jobGroup.Solution}, {jobGroup.TemplateDuration}, {jobGroup.ReferenceDate}" +
                $"{jobGroup.IsAutoDistributionEnabled}, {jobGroup.IsAgent}, {jobGroup.AgentName}" +
                $"{jobGroup.AgentTimeOutSec}, {jobGroup.AgentScript}");

            return NoContent();
        }
    }
}