using AutoMapper;
using Microsoft.EntityFrameworkCore;
using Serilog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WorkFlowCheck.BL.Services.Interfaces;
using WorkFlowCheck.Common.DTO;
using WorkFlowCheck.DL;
using WorkFlowCheck.DL.Entities;

namespace WorkFlowCheck.BL.Services
{
    public class CheckListService : ICheckListService
    {
        private AppDbContext _dbContext;
        private IMapper _mapper;
        private readonly INumberGeneratorService _numberGeneratorService;

        public CheckListService(AppDbContext dbContext, IMapper mapper, INumberGeneratorService numberGeneratorService)
        {
            _dbContext = dbContext;
            _mapper = mapper;
            _numberGeneratorService = numberGeneratorService;
        }

        public async Task<CheckListHeaderDTO> GetCheckListHeaderAsync(int Id)
        {
            var retVal = new CheckListHeaderDTO()
            {
                CheckListRowDTO = new List<CheckListRowDTO>()
            };

            try
            {
                var res = await _dbContext.CheckListHeaders
                                       .Where(w => w.Id == Id)
                                       .Include(i => i.CheckListRows)
                                       .AsNoTracking()
                                       .FirstOrDefaultAsync();

                if (res != null)
                {
                    retVal = _mapper.Map<CheckListHeaderDTO>(res);

                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }
        public async Task<List<CheckListHeaderDTO>> GetAllCheckListHeaderAsync()
        {
            var retVal = new List<CheckListHeaderDTO>();
            try
            {
                var roles = await _dbContext.CheckListHeaders
                                            .Include(i => i.CheckListRows)
                                            .Include(i => i.User)
                                            .AsNoTracking()
                                            .ToListAsync();
                if (roles != null)
                {
                    retVal = _mapper.Map<List<CheckListHeaderDTO>>(roles);
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }
            return retVal;
        }
        public async Task<CheckListHeaderDTO> UpdateCheckListHeaderAsync(CheckListHeaderDTO checkListHeaderDTO)
        {
            var retVal = new CheckListHeaderDTO() { CheckListRowDTO = new List<CheckListRowDTO>() };
            try
            {
                if (checkListHeaderDTO.Id == 0)
                {
                    var checkListHeader = new CheckListHeader()
                    {
                        CheckListTemplateHeaderId = checkListHeaderDTO.CheckListTemplateHeaderDTO.Id,
                        Description = checkListHeaderDTO.Description,
                        GuidNumber = Guid.NewGuid(),
                    };
                    _dbContext.CheckListHeaders.Add(checkListHeader);
                    await _dbContext.SaveChangesAsync();
                    retVal = _mapper.Map<CheckListHeaderDTO>(checkListHeader);
                }
                else
                {
                    var checkListHeader = await _dbContext.CheckListHeaders
                                            .Include(i => i.CheckListRows)
                                            .Where(w => w.Id == checkListHeaderDTO.Id)
                                            .FirstOrDefaultAsync();
                    if (checkListHeader != null)
                    {
                        checkListHeader.Description = checkListHeaderDTO.Description;


                        await _dbContext.SaveChangesAsync();
                        retVal = _mapper.Map<CheckListHeaderDTO>(checkListHeader);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }
        public async Task<CheckListHeaderDTO> StartNewCheckListAsync(CheckListHeaderNewDTO checkListHeaderNewDTO)
        {
            var retVal = new CheckListHeaderDTO()
            {
                CheckListRowDTO = new List<CheckListRowDTO>()
            };
            using var transaction = await _dbContext.Database.BeginTransactionAsync();
            try
            {
                var checkListTemplateHeader = await _dbContext.CheckListTemplateHeaders
                                                             .Where(w => w.Id == checkListHeaderNewDTO.CheckListTemplateHeaderId)
                                                             .FirstOrDefaultAsync();
                if (checkListTemplateHeader == null)
                {
                    return retVal;
                }
                var currentDate = DateTime.UtcNow;
                var documentNumber = await _numberGeneratorService.GenerateNextNumberAsync(checkListTemplateHeader.NumberGenerator1Id ?? 1, transaction, currentDate);
                CheckListHeader checkListHeader = new CheckListHeader()
                {
                    CheckListTemplateHeaderId = checkListHeaderNewDTO.CheckListTemplateHeaderId,
                    DateExecution = currentDate,
                    IsEditable = true,
                    UserId = checkListHeaderNewDTO.UserId,
                    ShortName = "",
                    Description = "",
                    DocumentNumber = documentNumber,
                    GuidNumber = Guid.NewGuid(),
                    IsDeleted = false,
                    IsStorno = false,
                    CheckListRows = new List<CheckListRow>()
                };


                _dbContext.CheckListHeaders.Add(checkListHeader);
                await _dbContext.SaveChangesAsync();

                var checkListTemplateRows = await _dbContext.CheckListTemplateRows
                                                    .Where(w => w.CheckListTemplateHeaderId == checkListHeaderNewDTO.CheckListTemplateHeaderId)
                                                    .OrderBy(o => o.RowIndex)
                                                    .ToListAsync();
                foreach (var item in checkListTemplateRows)
                {
                    CheckListRow checkListRow = new CheckListRow()
                    {
                        Answer = "",
                        CheckListHeaderId = checkListHeader.Id,
                        CheckListTemplateRowId = item.Id,
                        GuidNumber = Guid.NewGuid(),
                        IsDeleted = false,
                        Photo = new byte[0],
                    };
                    _dbContext.CheckListRows.Add(checkListRow);
                }

                await _dbContext.SaveChangesAsync();
                await transaction.CommitAsync();

                retVal = _mapper.Map<CheckListHeaderDTO>(checkListHeader);
            }
            catch (Exception ex)
            {
                await transaction.RollbackAsync();
                Log.Error(ex.Message);
            }
            return retVal;
        }

        public async Task<CheckListTemplateHeaderDTO> GetCheckListTemplateHeaderAsync(int Id)
        {
            var retVal = new CheckListTemplateHeaderDTO()
            {
                CheckListTemplateRowDTO = new List<CheckListTemplateRowDTO>()
            };

            try
            {
                var res = await _dbContext.CheckListTemplateHeaders
                                       .Where(w => w.Id == Id)
                                       .Include(i => i.CheckListTemplateRows)
                                            .ThenInclude(i => i.CheckPoint)
                                       .Include(i => i.CheckListTemplateRows)
                                            .ThenInclude(i => i.Equipment)
                                       .AsNoTracking()
                                       .FirstOrDefaultAsync();

                if (res != null)
                {
                    retVal = _mapper.Map<CheckListTemplateHeaderDTO>(res);

                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }
        public async Task<List<CheckListTemplateHeaderDTO>> GetAllCheckListTemplateHeaderAsync()
        {
            var retVal = new List<CheckListTemplateHeaderDTO>();
            try
            {
                var roles = await _dbContext.CheckListTemplateHeaders
                                            .Include(i => i.CheckListTemplateRows)
                                            .AsNoTracking()
                                            .ToListAsync();
                if (roles != null)
                {
                    retVal = _mapper.Map<List<CheckListTemplateHeaderDTO>>(roles);
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }
            return retVal;
        }
        public async Task<CheckListTemplateHeaderDTO> UpdateCheckListTemplateHeaderAsync(CheckListTemplateHeaderDTO checkListTemplateHeaderDTO)
        {
            var retVal = new CheckListTemplateHeaderDTO() { CheckListTemplateRowDTO = new List<CheckListTemplateRowDTO>() };
            try
            {
                if (checkListTemplateHeaderDTO.Id == 0)
                {
                    var checkListTemplateHeader = new CheckListTemplateHeader()
                    {
                        Description = checkListTemplateHeaderDTO.Description,
                        ShortName = checkListTemplateHeaderDTO.ShortName,
                        IsDeleted = false,

                    };
                    _dbContext.CheckListTemplateHeaders.Add(checkListTemplateHeader);
                    await _dbContext.SaveChangesAsync();
                    retVal = _mapper.Map<CheckListTemplateHeaderDTO>(checkListTemplateHeader);
                }
                else
                {
                    var checkListTemplateHeader = await _dbContext.CheckListTemplateHeaders
                                            .Include(i => i.CheckListTemplateRows)
                                            .Where(w => w.Id == checkListTemplateHeaderDTO.Id)
                                            .FirstOrDefaultAsync();
                    if (checkListTemplateHeader != null)
                    {
                        checkListTemplateHeader.Description = checkListTemplateHeaderDTO.Description;
                        checkListTemplateHeader.ShortName = checkListTemplateHeaderDTO.ShortName;

                        await _dbContext.SaveChangesAsync();
                        retVal = _mapper.Map<CheckListTemplateHeaderDTO>(checkListTemplateHeader);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }

        public async Task<CheckListTemplateRowDTO> GetCheckListTemplateRowAsync(int id)
        {
            var retVal = new CheckListTemplateRowDTO();
            try
            {
                var res = await _dbContext.CheckListTemplateRows
                                       .Include(i => i.Equipment)
                                       .Include(i => i.CheckPoint)
                                       .Where(w => w.Id == id)
                                       .AsNoTracking()
                                       .FirstOrDefaultAsync();

                if (res != null)
                {
                    retVal = _mapper.Map<CheckListTemplateRowDTO>(res);

                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }
        public async Task<CheckListTemplateRowDTO> UpdateCheckListTemplateRowAsync(CheckListTemplateRowDTO checkListTemplateRowDTO)
        {
            var retVal = new CheckListTemplateRowDTO() { };
            try
            {
                if (checkListTemplateRowDTO.Id == 0)
                {
                    var checkListTemplateRow = new CheckListTemplateRow()
                    {
                        CheckListTemplateHeaderId = checkListTemplateRowDTO.CheckListTemplateHeaderId,
                        CheckPointId = checkListTemplateRowDTO.CheckPointId,
                        EquipmentId = checkListTemplateRowDTO.EquipmentId,
                        OperationDescription = checkListTemplateRowDTO.OperationDescription,
                        AnswerType = checkListTemplateRowDTO.AnswerType,
                        RowIndex = checkListTemplateRowDTO.RowIndex,

                    };
                    _dbContext.CheckListTemplateRows.Add(checkListTemplateRow);
                    await _dbContext.SaveChangesAsync();
                    retVal = _mapper.Map<CheckListTemplateRowDTO>(checkListTemplateRow);
                }
                else
                {
                    var checkListTemplateRow = await _dbContext.CheckListTemplateRows
                                            .Where(w => w.Id == checkListTemplateRowDTO.Id)
                                            .FirstOrDefaultAsync();
                    if (checkListTemplateRow != null)
                    {
                        checkListTemplateRow.CheckListTemplateHeaderId = checkListTemplateRowDTO.CheckListTemplateHeaderId;
                        checkListTemplateRow.CheckPointId = checkListTemplateRowDTO.CheckPointId;
                        checkListTemplateRow.EquipmentId = checkListTemplateRowDTO.EquipmentId;
                        checkListTemplateRow.OperationDescription = checkListTemplateRowDTO.OperationDescription;
                        checkListTemplateRow.AnswerType = checkListTemplateRowDTO.AnswerType;
                        checkListTemplateRow.RowIndex = checkListTemplateRowDTO.RowIndex;

                        await _dbContext.SaveChangesAsync();
                        retVal = _mapper.Map<CheckListTemplateRowDTO>(checkListTemplateRow);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }
    }
}