using AutoMapper;
using DocumentFormat.OpenXml.InkML;
using DocumentFormat.OpenXml.Office2010.Excel;
using DocumentFormat.OpenXml.Spreadsheet;
using Microsoft.EntityFrameworkCore;
using Serilog;
using System.Collections.Generic;
using WorkFlowCheck.BL.Services.Interfaces;
using WorkFlowCheck.Common.DTO;
using WorkFlowCheck.Common.Enums;
using WorkFlowCheck.Common.RequestContext;
using WorkFlowCheck.DL;
using WorkFlowCheck.DL.Entities;

namespace WorkFlowCheck.BL.Services
{
    public class SyncService : BaseService, ISyncService
    {
        private readonly IRequestContext _requestContext;
        private readonly IUserService _userService;
        private readonly IMessageService _messageService;

        public SyncService(AppDbContext dbContext,
                           IMapper mapper,
                           IRequestContext requestContext,
                           IMessageService messageService,
                           IUserService userService) : base(dbContext, mapper)
        {
            _requestContext = requestContext;
            _userService = userService;
            _messageService = messageService;
        }

        public async Task<List<CheckPointDTO>> GetAllCheckPointAsync()
        {
            var retVal = new List<CheckPointDTO>();

            try
            {
                var res = await _dbContext.CheckPoints
                                         .Include(i => i.CheckListTemplateRows)
                                         .AsNoTracking()
                                         .ToListAsync();
                if (res != null)
                {
                    retVal = _mapper.Map<List<CheckPointDTO>>(res);
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }
        public async Task<CheckPointDTO> GetCheckPointAsync(int id)
        {
            var retVal = new CheckPointDTO();

            try
            {
                var checkpoint = await _dbContext.CheckPoints
                                         .Include(i => i.CheckListTemplateRows)
                                         .Where(w => w.Id == id)
                                         .AsNoTracking()
                                         .FirstOrDefaultAsync();
                if (checkpoint != null)
                {
                    retVal = _mapper.Map<CheckPointDTO>(checkpoint);

                    var role = await _dbContext.Roles.Where(w => w.Id == retVal.RoleId).FirstOrDefaultAsync();

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

            return retVal;
        }
        public async Task<bool> DeleteCheckPointAsync(int id)
        {
            return await DeleteEntityByIdAsync<CheckPoint>(id);
        }
        public async Task<CheckPointDTO> UpdateCheckPointAsync(CheckPointDTO checkPointDTO)
        {
            var retVal = new CheckPointDTO();

            try
            {
                if (checkPointDTO.Id == 0) //Hozzáadás, ha Id == 0
                {
                    var checkPoint = _mapper.Map<CheckPoint>(checkPointDTO);
                    _dbContext.CheckPoints.Add(checkPoint);
                    await _dbContext.SaveChangesAsync();

                    retVal = _mapper.Map<CheckPointDTO>(checkPoint);
                }
                else
                {
                    var res = await _dbContext.CheckPoints.Where(w => w.Id == checkPointDTO.Id).FirstOrDefaultAsync();
                    if (res != null)
                    {
                        res.ShortName = checkPointDTO.ShortName;
                        res.Code = checkPointDTO.Code;
                        res.IsEnabled = checkPointDTO.IsEnabled;

                        await _dbContext.SaveChangesAsync();

                        retVal = _mapper.Map<CheckPointDTO>(res);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }
        public async Task<List<CheckPointDTO>> UpdateAllCheckPointAsync(List<CheckPointDTO> checkPointListDTO)
        {
            var retVal = new List<CheckPointDTO>();
            try
            {
                var ids = checkPointListDTO.Select(dto => dto.Id).ToList();
                var checkPoints = await _dbContext.CheckPoints
                    .Where(cp => ids.Contains(cp.Id))
                    .ToListAsync();

                foreach (var checkPoint in checkPoints)
                {
                    var dto = checkPointListDTO.FirstOrDefault(d => d.Id == checkPoint.Id);
                    if (dto != null)
                    {
                        checkPoint.Code = dto.Code;
                    }
                }
                await _dbContext.SaveChangesAsync();
                retVal = _mapper.Map<List<CheckPointDTO>>(checkPoints);
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }
            return retVal;
        }

        public async Task<List<LocationDTO>> GetAllLocationAsync()
        {
            var retVal = new List<LocationDTO>();

            try
            {
                var res = await _dbContext.Locations.ToListAsync();
                if (res != null)
                {
                    retVal = _mapper.Map<List<LocationDTO>>(res);
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }
        public async Task<LocationDTO> GetLocationAsync(int id)
        {
            var retVal = new LocationDTO();

            try
            {
                var res = await _dbContext.Locations
                                         .Where(w => w.Id == id)
                                         .AsNoTracking()
                                         .FirstOrDefaultAsync();
                if (res != null)
                {
                    retVal = _mapper.Map<LocationDTO>(res);
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }
        public async Task<bool> DeleteLocationAsync(int id)
        {
            return await DeleteEntityByIdAsync<DL.Entities.Location>(id);
        }
        public async Task<LocationDTO> UpdateLocationAsync(LocationDTO LocationDTO)
        {
            var retVal = new LocationDTO();

            try
            {
                if (LocationDTO.Id == 0) //Hozzáadás, ha Id == 0
                {
                    var Location = _mapper.Map<DL.Entities.Location>(LocationDTO);
                    _dbContext.Locations.Add(Location);
                    await _dbContext.SaveChangesAsync();

                    retVal = _mapper.Map<LocationDTO>(Location);
                }
                else
                {
                    var res = await _dbContext.Locations.Where(w => w.Id == LocationDTO.Id).FirstOrDefaultAsync();
                    if (res != null)
                    {
                        res.FullName = LocationDTO.FullName;
                        await _dbContext.SaveChangesAsync();

                        retVal = _mapper.Map<LocationDTO>(res);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }

        public async Task<List<EquipmentDTO>> GetAllEquipmentAsync()
        {
            var retVal = new List<EquipmentDTO>();

            try
            {
                var res = await _dbContext.Equipments.ToListAsync();
                if (res != null)
                {
                    retVal = _mapper.Map<List<EquipmentDTO>>(res);
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }
        public async Task<EquipmentDTO> GetEquipmentAsync(int id)
        {
            var retVal = new EquipmentDTO();

            try
            {
                var res = await _dbContext.Equipments
                                         .Where(w => w.Id == id)
                                         .AsNoTracking()
                                         .FirstOrDefaultAsync();
                if (res != null)
                {
                    retVal = _mapper.Map<EquipmentDTO>(res);
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }
        public async Task<bool> DeleteEquipmentAsync(int id)
        {
            return await DeleteEntityByIdAsync<Equipment>(id);
        }
        public async Task<EquipmentDTO> UpdateEquipmentAsync(EquipmentDTO EquipmentDTO)
        {
            var retVal = new EquipmentDTO();

            try
            {
                if (EquipmentDTO.Id == 0) //Hozzáadás, ha Id == 0
                {
                    var Equipment = _mapper.Map<Equipment>(EquipmentDTO);
                    _dbContext.Equipments.Add(Equipment);
                    await _dbContext.SaveChangesAsync();

                    retVal = _mapper.Map<EquipmentDTO>(Equipment);
                }
                else
                {
                    var res = await _dbContext.Equipments.Where(w => w.Id == EquipmentDTO.Id).FirstOrDefaultAsync();
                    if (res != null)
                    {
                        res.ShortName = EquipmentDTO.ShortName;
                        res.EquipmentNumber = EquipmentDTO.EquipmentNumber;

                        await _dbContext.SaveChangesAsync();

                        retVal = _mapper.Map<EquipmentDTO>(res);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }

        public async Task<List<CheckListTemplateHeaderDTO>> GetAllCheckListTemplateAsync(int userId)
        {
            var retVal = new List<CheckListTemplateHeaderDTO>();

            try
            {
                var user = _dbContext.Users.Where(w => w.Id == userId).FirstOrDefault();
                if (user != null)
                {
                    var res = await (from ur in _dbContext.UserRoles
                                     join rth in _dbContext.RoleCheckListTemplateHeaders on ur.RoleId equals rth.RoleId
                                     join header in _dbContext.CheckListTemplateHeaders on rth.CheckListTemplateHeaderId equals header.Id
                                     where ur.UserId == userId
                                     select header)
                                .Include(h => h.CheckListTemplateRows)
                                .Distinct()
                                .AsNoTracking()
                                .ToListAsync();

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

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

            return retVal;
        }
        public async Task<List<CheckListHeaderDTO>> GetAllCheckListAsync(int userId)
        {
            var retVal = new List<CheckListHeaderDTO>();

            try
            {
                var res = await _dbContext.CheckListHeaders
                                          .Where(w => w.CheckStatus == CheckStatus.Open ||
                                                      w.CheckStatus == CheckStatus.InProgress ||
                                                      w.CheckStatus == CheckStatus.Blocked ||
                                                      w.CheckStatus == CheckStatus.Sent)
                                          .Include(i => i.CheckListRows)
                                          //.ThenInclude(i => i.CheckListTemplateRow)
                                          .AsNoTracking()
                                          .ToListAsync();

                if (res != null)
                {
                    retVal = _mapper.Map<List<CheckListHeaderDTO>>(res);
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }

        public async Task<CheckListHeaderDTO> SendCheckListHeaderAsync(CheckListHeaderDTO checkListHeaderDTO)
        {
            var retVal = new CheckListHeaderDTO();

            try
            {
                if (checkListHeaderDTO.Id > 0)
                {
                    var res = await _dbContext.CheckListHeaders
                                              .Include(i => i.CheckListRows)
                                              .Where(w => w.Id == checkListHeaderDTO.Id)
                                              .FirstOrDefaultAsync();
                    if (res != null && (res.CheckStatus == CheckStatus.Open ||
                                        res.CheckStatus == CheckStatus.InProgress))
                    {
                        var ids = checkListHeaderDTO.CheckListRowDTO?.Select(r => r.Id).ToList();
                        if (ids != null && ids.Count > 0)
                        {
                            var rowsToUpdate = await _dbContext.CheckListRows
                                                    .Where(r => ids.Contains(r.Id))
                                                    .ToListAsync();
                            foreach (var row in rowsToUpdate)
                            {
                                var dtoRow = checkListHeaderDTO.CheckListRowDTO?.FirstOrDefault(r => r.Id == row.Id);
                                if (dtoRow != null)
                                {
                                    row.Answer = dtoRow.Answer;
                                    if (dtoRow.Photo != null && dtoRow.Photo.Length > 0)
                                    {

                                        string imageDirectory = Path.Combine(Directory.GetCurrentDirectory(), "Images");
                                        var timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
                                        var fileName = $"PH_{timestamp}_{row.CheckListHeaderId}_{row.Id}.jpeg";
                                        row.PhotoFileName = fileName;
                                        var filePath = Path.Combine(imageDirectory, fileName);
                                        await File.WriteAllBytesAsync(filePath, dtoRow.Photo);
                                        row.Answer = fileName;
                                    }
                                }
                            }
                        }
                        await _dbContext.SaveChangesAsync();
                        retVal = _mapper.Map<CheckListHeaderDTO>(res);
                        string Answer = "";
                        if (NeedBlocking(checkListHeaderDTO, out Answer))
                        {
                            /// TODO: blokkolás miatt
                            res.CheckStatus = CheckStatus.Blocked;
                            await _dbContext.SaveChangesAsync();

                            Log.ForContext("TAG", "BusinessFlow").Warning($"Ellenőrzési lap blokkolva: Ellenőrzés:{checkListHeaderDTO.Id}, Felhasználó:{_requestContext.CurrentUsername}");

                            var user = await _userService.GetUserAsync(_requestContext.CurrentUserId ?? 1);

                            foreach (var item in user.RoleDTO)
                            {
                                var deviceMessageDTO = new DeviceMessageDTO()
                                {
                                    IsReaded = false,
                                    Message = $"Ellenőrző lap blokkolva! [{checkListHeaderDTO.DocumentNumber}]\n({Answer})",
                                    SendDate = DateTime.UtcNow,
                                    ExtraDataJSON = "",
                                    RoleId = item.ParentId,
                                    DeviceIdFrom = "",
                                    DeviceIdTo = "",
                                };

                                await this.DeviceMessageSend(deviceMessageDTO);

                                var fCMMessageDTO = new FCMMessageDTO
                                {
                                    Body = deviceMessageDTO.Message,
                                    Title = "Blokkolási értesítés",
                                    UserId = user.Id,
                                };
                                await _messageService.SendFCMMessageToLastToken(fCMMessageDTO);
                            }
                            return retVal;
                        }

                        res.CheckStatus = CheckStatus.InProgress;

                        if (CheckIfLastReached(checkListHeaderDTO))
                        {
                            /// TODO: most kell a CheckStatust állítani és menjen üzenet !
                            res.CheckStatus = CheckStatus.Sent;
                            Log.ForContext("TAG", "BusinessFlow").Warning($"Ellenőrzési lap státuszváltozása: Ellenőrzés:{checkListHeaderDTO.Id}, Felhasználó:{_requestContext.CurrentUsername}");

                        }

                        await _dbContext.SaveChangesAsync();


                        retVal = _mapper.Map<CheckListHeaderDTO>(res);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }

            return retVal;
        }
        private bool NeedBlocking(CheckListHeaderDTO checkListHeaderDTO, out string Answer)
        {
            var retVal = false;
            Answer = "";
            if (checkListHeaderDTO.CheckListRowDTO != null && checkListHeaderDTO.CheckListRowDTO.Count > 0)
            {
                var checkListRows = checkListHeaderDTO.CheckListRowDTO;
                foreach (var row in checkListRows)
                {
                    if (!string.IsNullOrEmpty(row.Answer))
                    {
                        if (row.CheckListTemplateRowDTO != null)
                        {
                            Answer = row.CheckListTemplateRowDTO.OperationDescription;
                            if (row.CheckListTemplateRowDTO.AnswerType == "PI-N" && row.Answer == "Igen")
                            {
                                retVal = true;
                                break;
                            }
                            if (row.CheckListTemplateRowDTO.AnswerType == "I-PN" && row.Answer == "Nem")
                            {
                                retVal = true;
                                break;
                            }

                        }
                    }
                }
            }

            return retVal;
        }
        private bool CheckIfLastReached(CheckListHeaderDTO checkListHeaderDTO)
        {
            var retVal = false;

            if (checkListHeaderDTO != null && checkListHeaderDTO.CheckListRowDTO != null && checkListHeaderDTO.CheckListRowDTO.Count > 0)
            {
                var totalRowCount = checkListHeaderDTO.CheckListRowDTO.Where(w => w.CheckListTemplateRowDTO.AnswerType != "PN" &&
                                                                              w.CheckListTemplateRowDTO.CheckPointDTO.IsEnabled == true).Count();

                var answeredCount = checkListHeaderDTO.CheckListRowDTO.Where(w => w.CheckListTemplateRowDTO.AnswerType != "PN" &&
                                                                                  w.CheckListTemplateRowDTO.CheckPointDTO.IsEnabled == true &&
                                                                                  string.IsNullOrEmpty(w.Answer) != true).Count();

                if (totalRowCount == answeredCount) { retVal = true; }
            }


            return retVal;
        }
        public async Task<bool> DeviceMessageSend(DeviceMessageDTO deviceMessageDTO)
        {
            var retVal = false;
            try
            {
                var deviceMessage = _mapper.Map<DeviceMessage>(deviceMessageDTO);
                deviceMessage.SendDate = DateTime.UtcNow;
                deviceMessage.IsReaded = false;
                _dbContext.DeviceMessages.Add(deviceMessage);
                await _dbContext.SaveChangesAsync(true);
                retVal = true;
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }
            return retVal;
        }
        public async Task<List<DeviceMessageDTO>> DeviceMessageReadUnreaded(string deviceId)
        {
            var retVal = new List<DeviceMessageDTO>();
            try
            {
                var res = await _dbContext.DeviceMessages
                                    .Where(w => w.DeviceIdTo == deviceId && w.IsReaded != true)
                                    .ToListAsync();

                if (res != null)
                {
                    retVal = _mapper.Map<List<DeviceMessageDTO>>(res);
                    foreach (var deviceMessage in res)
                    {
                        deviceMessage.IsReaded = true;
                        deviceMessage.ReceiveDate = DateTime.UtcNow;
                    }
                    await _dbContext.SaveChangesAsync();
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }
            return retVal;
        }
        public async Task<List<DeviceMessageDTO>> DeviceMessageReadUnreadedRole(int roleId)
        {
            var retVal = new List<DeviceMessageDTO>();
            try
            {
                var res = await _dbContext.DeviceMessages
                                    .Where(w => w.RoleId == roleId && w.IsReaded != true)
                                    .ToListAsync();

                if (res != null)
                {
                    retVal = _mapper.Map<List<DeviceMessageDTO>>(res);
                    foreach (var deviceMessage in res)
                    {
                        deviceMessage.IsReaded = true;
                        deviceMessage.ReceiveDate = DateTime.UtcNow;
                    }
                    await _dbContext.SaveChangesAsync();
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
            }
            return retVal;
        }
    }
}