using AutoMapper;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using Ropin.Inspection.Common.Accessor.Interface;
using Ropin.Inspection.Common.Helper;
using Ropin.Inspection.Model.Entities;
using Ropin.Inspection.Model.SearchModel;
using Ropin.Inspection.Model.ViewModel;
using Ropin.Inspection.Repository;
using Ropin.Inspection.Repository.Interface;
using Ropin.Inspection.Service.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

namespace Ropin.Inspection.Service
{
    /*
0. 巡检内容都正常，状态：1，巡检点正常，状态：1  
1. 巡检内容有一个异常，状态：0，巡检点异常，状态：2 ， 
2. 巡检内容有一个确认异常，状态：3，巡检点确认异常，状态：3
3. 巡检内容全恢复正常，状态：2，巡检点正常，状态：1
4. 巡检内容全取消异常，状态：4，巡检点正常，状态：1
5. 再次巡检，相同的巡检内容异常或者确认异常，状态：5；巡检点逻辑不变，状态同上


巡检异常，recordItem创建时间有值，更新时间NULL
取消异常，recordItem更新时间有值，新建一条recordItem取消记录，创建时间有值，更新时间NULL
确认异常，recordItem更新时间有值，新建一条recordItem确认记录，创建时间有值，更新时间NULL
恢复异常，recordItem更新时间有值，新建一条recordItem恢复记录，创建时间有值，更新时间NULL


巡检异常(状态：1,更新时间null)->取消异常（添加更新时间，创建取消异常记录，状态：4）
巡检异常(状态：1,更新时间null)->确认异常(添加更新时间，创建确认异常记录，状态：3)->恢复异常（添加确认异常记录更新时间，创建恢复异常记录，状态：2）
     */
    public class TispRecordItemService : ITispRecordItemService
    {
        private readonly ITispRecordItemRepository _repository;
        private readonly ITispRecordImageRepository _tispRecordImageRepository;
        private readonly ITispRecordRepository _tispRecordRepository;
        private readonly IMapper _mapper;
        private readonly IClaimsAccessor _claims;
        private readonly IHttpClientFactory _httpClientFactory;
        private readonly ITsysUserRepository _tsysUserRepository;
        private readonly IPushMsgService _pushMsgService;

        public TispRecordItemService(IClaimsAccessor claims, IHttpClientFactory httpClientFactory, ITispRecordItemRepository repository, ITispRecordImageRepository tispRecordImageRepository, ITispRecordRepository tispRecordRepository, ITsysUserRepository tsysUserRepository, IMapper mapper, IPushMsgService pushMsgService)
        {
            _repository = repository;
            _tispRecordImageRepository = tispRecordImageRepository;
            _tispRecordRepository = tispRecordRepository;
            _mapper = mapper;
            _claims = claims;
            _httpClientFactory = httpClientFactory;
            _tsysUserRepository = tsysUserRepository;
            _pushMsgService = pushMsgService;
        }

        public Task CreateOneAsync(TispRecordItem viewModel)
        {
            throw new NotImplementedException();
        }

        public Task DeleteAsync(Guid id)
        {
            throw new NotImplementedException();
        }

        public Task<TispRecordItem> GetByIdAsync(Guid id)
        {
            throw new NotImplementedException();
        }

        public async Task<IEnumerable<TispRecordItemDetailViewModel>> GetRecordsConditionAsync(Guid recordId)
        {
            var result = await _repository.GetRecordsConditionAsync(recordId);
            return result;
        }
        public async Task<List<List<TispRecordItemDetailViewModel>>> GetRecordItemsByRecordIdAsync(Guid recordId)
        {
            var result = await _repository.GetRecordItemsByRecordIdAsync(recordId);
            return result;
        }
        public async Task<IEnumerable<FirePreventionWeekRecordViewModel>> GetFirePreventionWeekRecordAsync(DateTime start, DateTime end, string storeCode)
        {
            var result = await _repository.GetFirePreventionWeekRecordAsync(start,end, storeCode);
            return result;
        }
        public async Task<IEnumerable<FireFightingFacilitiesWeekRecordViewModel>> GetFireFightingFacilitiesAsync(DateTime start, DateTime end, string storeCode)
        {
            var result = await _repository.GetFireFightingFacilitiesAsync(start, end, storeCode);
            return result;
        }
        public async Task<IEnumerable<FireInspectionRecordViewModel>> GetFireInspectionRecordAsync(DateTime start, DateTime end, string storeCode)
        {
            var result = await _repository.GetFireInspectionRecordAsync(start, end, storeCode);
            return result;
        }
        public async Task<HiddenDangerRectificationAcceptanceFormViewModel> HiddenDangerRectificationAcceptanceForm(DateTime start, DateTime end, string storeCode)
        {
            var result = await _repository.HiddenDangerRectificationAcceptanceForm(start, end, storeCode);
            return result;
        }
        public async Task<IEnumerable<TispRecordItemDetailViewModel>> GetAlarmRecordsAsync(TispRecordAlarmSearchModel searchModel)
        {
            var pagedList = await _repository.GetAlarmRecordsAsync(searchModel);
            searchModel.TotalCount = pagedList!=null? pagedList.Totals:0;
            return pagedList != null? pagedList.Rows:null;
        }
        public async Task<IEnumerable<TispRecordItemDetailViewModel>> GetAlarmRecordListAsync(TispRecordAlarmSearchModel searchModel)
        {
            var pagedList = await _repository.GetAlarmRecordListAsync(searchModel);
            searchModel.TotalCount = pagedList != null ? pagedList.Totals : 0;
            return pagedList != null ? pagedList.Rows : null;
        }
        public async Task<IEnumerable<TispRecordItemDetailViewModel>> GetAlarmRecoveryRecordsAsync(TispRecordAlarmSearchModel searchModel)
        {
            var pagedList = await _repository.GetAlarmRecoveryRecordsAsync(searchModel);
            searchModel.TotalCount = pagedList != null ? pagedList.Totals : 0;
            return pagedList != null ? pagedList.Rows : null;
        }
        public async Task<int> GetAlarmRecordsCountAsync(TispRecordAlarmSearchModel searchModel)
        {
            var result = await _repository.GetAlarmRecordsCountAsync(searchModel);
            return result;
        }
        public async Task<int> GetAlarmRecoveryRecordsCountAsync(TispRecordAlarmSearchModel searchModel)
        {
            var result = await _repository.GetAlarmRecoveryRecordsCountAsync(searchModel);
            return result;
        }
        public async Task<IEnumerable<TispRecordItemDetailViewModel>> GetRecordItemByIdAsync(Guid id)
        {
            var result = await _repository.GetRecordItemByIdAsync(id);
            return result;
        }
        public async Task<IEnumerable<TispRecordItemAlarmDetailViewModel>> GetAlarmRecordsByQRCodeAsync(string QRCode, string storeCode)
        {
            var result = await _repository.GetAlarmRecordsByQRCodeAsync(QRCode, storeCode);
            return result;
        }
        public async Task<IEnumerable<TispRecordItemAlarmDetailViewModel>> GetNewRecordByQRCodeAsync(string QRCode, string storeCode)
        {
            var result = await _repository.GetNewRecordByQRCodeAsync(QRCode, storeCode);
            return result;
        }
        public Task<bool> IsExistAsync(Guid id)
        {
            throw new NotImplementedException();
        }

        public Task<int> UpdateOneAsync(TispRecordItem viewModel, params string[] fields)
        {
            throw new NotImplementedException();
        }
        public async Task CancelRecordItemAlarmAsync(Guid recordItemId, TispRecoveryRecordItemAlarmUpdateViewModel updateModel)
        {
            var recordItem = await _repository.GetByIdAsync(recordItemId);
            if (null == recordItem)
            {
                throw new Exception("取消失败，没有此巡检内容记录");
            }
            recordItem.C_LastUpdatedBy = _claims.ApiUserId;
            recordItem.D_LastUpdatedOn = DateTime.Now;
            _repository.Update(recordItem);
            var result = await _repository.SaveAsync();

            recordItem.C_ID = Guid.NewGuid();
            recordItem.C_Remark = updateModel.C_Remark;
            recordItem.C_Status = "4";
            recordItem.C_CreateBy = _claims.ApiUserId;
            recordItem.D_CreateOn = DateTime.Now;
            recordItem.C_LastUpdatedBy = null;
            recordItem.D_LastUpdatedOn = null;
            _repository.Create(recordItem);
            result = await _repository.SaveAsync();
            if (!result)
            {
                throw new Exception("取消失败");
            }

            if (null != updateModel.FilePaths && updateModel.FilePaths.Any())
            {
                foreach (string imgPath in updateModel.FilePaths)
                {
                    await _tispRecordImageRepository.CreateOneAsync(new TISP_RecordImage { C_RecordItemCode = recordItem.C_ID, C_ImageUrl = imgPath, C_Status = "4" });
                    var resultItemImage = await _repository.SaveAsync();
                    if (!resultItemImage)
                    {
                        throw new Exception("取消失败");
                    }
                }
            }

            var recordItems = await _repository.GetByConditionAsync(i => i.C_RecordCode == recordItem.C_RecordCode);
            if (null != recordItems && recordItems.Where(i => (i.C_Status == "0" && i.D_LastUpdatedOn == null) || (i.C_Status == "3" && i.D_LastUpdatedOn == null)).Any())
            {

            }
            else
            {
                TISP_Record record = await _tispRecordRepository.GetByIdAsync(recordItem.C_RecordCode);
                record.C_Status = "1";//正常
                record.C_LastUpdatedBy = _claims.ApiUserId;
                record.D_LastUpdatedOn = DateTime.Now;
                _tispRecordRepository.Update(record);
                await _tispRecordRepository.SaveAsync();
            }
            //var recordItem = await _repository.GetByIdAsync(recordItemId);
            //if (null == recordItem)
            //{
            //    throw new Exception("更新失败，没有此巡检内容记录");
            //}
            //recordItem.C_ID = Guid.NewGuid();
            //recordItem.C_Remark = updateModel.C_Remark;
            //recordItem.C_Status = "1";
            //recordItem.C_LastUpdatedBy = _claims.ApiUserId;
            //recordItem.D_LastUpdatedOn = DateTime.Now;
            //_repository.Update(recordItem);
            //var result = await _repository.SaveAsync();
            //if (!result)
            //{
            //    throw new Exception("更新失败");
            //}


            //await _tispRecordImageRepository.DeleteByRecordItemIdAsync(recordItemId);
            //IEnumerable<TispRecordItemDetailViewModel> recordItems = await _repository.GetRecordsConditionAsync(recordItem.C_RecordCode);
            //if(null != recordItems && !recordItems.Where(i => i.C_Status == "0").Any())
            //{
            //    TISP_Record record = await _tispRecordRepository.GetByIdAsync(recordItem.C_RecordCode);
            //    record.C_Status = "1";//正常
            //    record.C_LastUpdatedBy = _claims.ApiUserId;
            //    record.D_LastUpdatedOn = DateTime.Now;
            //    _tispRecordRepository.Update(record);
            //    await _tispRecordRepository.SaveAsync();
            //}

            IEnumerable<TispRecordItemAlarmDetailViewModel> itemDetails = await _repository.GetAlarmRecordsByRecordItemIdAsync(recordItemId);
            TispRecordItemAlarmDetailViewModel itemDetail = itemDetails.FirstOrDefault();
            if (itemDetail == null) return;
            await _pushMsgService.PushRecordMsgAsync("MSG_TYPE_005", itemDetail);
        }
        public async Task RecoveryRecordItemAlarmAsync(Guid recordItemId, TispRecoveryRecordItemAlarmUpdateViewModel updateModel)
        {
            var recordItem = await _repository.GetByIdAsync(recordItemId);
            if (null == recordItem)
            {
                throw new Exception("更新失败，没有此巡检内容记录");
            }
            recordItem.C_LastUpdatedBy = _claims.ApiUserId;
            recordItem.D_LastUpdatedOn = DateTime.Now;
            _repository.Update(recordItem);
            var result = await _repository.SaveAsync();
            if (!result)
            {
                throw new Exception("恢复失败");
            }


            recordItem.C_ID = Guid.NewGuid();
            recordItem.C_Remark = updateModel.C_Remark;
            recordItem.C_Status = "2";
            recordItem.C_CreateBy = _claims.ApiUserId;
            recordItem.D_CreateOn = DateTime.Now;
            recordItem.C_LastUpdatedBy = null;
            recordItem.D_LastUpdatedOn = null;
            _repository.Create(recordItem);
            result = await _repository.SaveAsync();
            if (!result)
            {
                throw new Exception("恢复失败");
            }

            if (null != updateModel.FilePaths && updateModel.FilePaths.Any())
            {
                foreach (string imgPath in updateModel.FilePaths)
                {
                    await _tispRecordImageRepository.CreateOneAsync(new TISP_RecordImage { C_RecordItemCode = recordItem.C_ID, C_ImageUrl = imgPath, C_Status = "2" });
                    var resultItemImage = await _repository.SaveAsync();
                    if (!resultItemImage)
                    {
                        throw new Exception("创建失败");
                    }
                }
            }

            var recordItems = await _repository.GetByConditionAsync(i=>i.C_RecordCode == recordItem.C_RecordCode);

            if (null != recordItems && recordItems.Where(i=>(i.C_Status == "0" && i.D_LastUpdatedOn == null) || (i.C_Status == "3" && i.D_LastUpdatedOn == null)).Any())
            {

            }
            else
            {
                TISP_Record record = await _tispRecordRepository.GetByIdAsync(recordItem.C_RecordCode);
                record.C_Status = "1";//正常
                record.C_LastUpdatedBy = _claims.ApiUserId;
                record.D_LastUpdatedOn = DateTime.Now;
                _tispRecordRepository.Update(record);
                await _tispRecordRepository.SaveAsync();
            }


            IEnumerable<TispRecordItemAlarmDetailViewModel> itemDetails = await _repository.GetAlarmRecordsByRecordItemIdAsync(recordItemId);
            TispRecordItemAlarmDetailViewModel itemDetail = itemDetails.FirstOrDefault();
            if (itemDetail == null) return;
            await _pushMsgService.PushRecordMsgAsync("MSG_TYPE_005", itemDetail);
        }

        public async Task ConfirmRecordItemAlarmAsync(Guid recordItemId, TispRecoveryRecordItemAlarmUpdateViewModel updateModel)
        {
            var recordItem = await _repository.GetByIdAsync(recordItemId);
            if (null == recordItem)
            {
                throw new Exception("确认失败，没有此巡检内容记录");
            }
            recordItem.C_LastUpdatedBy = _claims.ApiUserId;
            recordItem.D_LastUpdatedOn = DateTime.Now;
            _repository.Update(recordItem);
            var result = await _repository.SaveAsync();
            


            recordItem.C_ID = Guid.NewGuid();
            recordItem.C_Remark = updateModel.C_Remark;
            recordItem.C_Status = "3";
            recordItem.C_CreateBy = _claims.ApiUserId;
            recordItem.D_CreateOn = DateTime.Now;
            recordItem.C_LastUpdatedBy = null;
            recordItem.D_LastUpdatedOn = null;
            _repository.Create(recordItem);
            result = await _repository.SaveAsync();
            if (!result)
            {
                throw new Exception("确认失败");
            }

            if (null != updateModel.FilePaths && updateModel.FilePaths.Any())
            {
                foreach (string imgPath in updateModel.FilePaths)
                {
                    await _tispRecordImageRepository.CreateOneAsync(new TISP_RecordImage { C_RecordItemCode = recordItem.C_ID, C_ImageUrl = imgPath, C_Status = "3" });
                    var resultItemImage = await _repository.SaveAsync();
                    if (!resultItemImage)
                    {
                        throw new Exception("创建失败");
                    }
                }
            }


            TISP_Record record = await _tispRecordRepository.GetByIdAsync(recordItem.C_RecordCode);
            record.C_Status = "3"; //确认异常
            record.C_LastUpdatedBy = _claims.ApiUserId;
            record.D_LastUpdatedOn = DateTime.Now;
            _tispRecordRepository.Update(record);
            await _tispRecordRepository.SaveAsync();


            IEnumerable<TispRecordItemAlarmDetailViewModel> itemDetails = await _repository.GetAlarmRecordsByRecordItemIdAsync(recordItemId);
            TispRecordItemAlarmDetailViewModel itemDetail = itemDetails.FirstOrDefault();
            if (itemDetail == null) return;

            await _pushMsgService.PushRecordMsgAsync("MSG_TYPE_004", itemDetail);
        }

        public async Task UpdateRecordItemAsync(Guid recordItemId, TispRecordItemUpdateViewModel updateModel)
        {
            var recordItem = await _repository.GetByIdAsync(recordItemId);
            if (null == recordItem)
            {
                throw new Exception("更新失败，没有此巡检内容记录");
            }
            recordItem.C_Remark = updateModel.C_Remark;
            recordItem.C_Status = updateModel.C_Status.ToString();
            recordItem.C_LastUpdatedBy = _claims.ApiUserId;
            recordItem.D_LastUpdatedOn = DateTime.Now;
            _repository.Update(recordItem);
            var result = await _repository.SaveAsync();
            if (!result)
            {
                throw new Exception("更新失败");
            }
        }
    }
}