using Abp.Auditing;
using Abp.Authorization;
using Abp.Collections.Extensions;
using Abp.Domain.Entities;
using Abp.Domain.Repositories;
using Abp.Domain.Uow;
using Abp.EntityFrameworkCore.Repositories;
using Microsoft.AspNetCore.Mvc;
using MongoDB.Driver.Linq;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Text;
using System.Threading.Tasks;
using ToolLibrary.LogHelper;
using YunDa.ISAS.Application.Core;
using YunDa.ISAS.Application.Core.Session;
using YunDa.ISAS.Application.Core.SwaggerHelper;
using YunDa.ISAS.DataTransferObject;
using YunDa.ISAS.DataTransferObject.CommonDto;
using YunDa.ISAS.DataTransferObject.DataMonitoring.TelemeteringConfigurationDto;
using YunDa.ISAS.Entities.DataMonitoring;
using YunDa.ISAS.Entities.GeneralInformation;
using YunDa.ISAS.Redis.Repositories;
using YunDa.ISMS.BASE.Entities.Models;
using YunDa.SOMS.DataTransferObject.GeneralInformation.ProtectionDeviceInfoDto;
using YunDa.SOMS.DataTransferObject.GeneralInformation.ProtectionDeviceInfoDto.HistoryData;
using YunDa.SOMS.DataTransferObject.GeneralInformation.ProtectionDeviceInfoDto.SearchCondition;
using YunDa.SOMS.DataTransferObject.GeneralInformation.ProtectionSettingDto;
using YunDa.SOMS.DataTransferObject.MainStationMaintenanceInfo.OperationReport;
using YunDa.SOMS.Entities.GeneralInformation;
using static NetMQ.NetMQSelector;

namespace YunDa.ISAS.Application.GeneralInformation
{
    /// <summary>
    /// 保护装置履历信息管理类
    /// </summary>
    public class ProtectionDeviceAppService : ISASAppServiceBase,IProtectionDeviceAppService
    {
        private readonly IRepository<EquipmentInfo, Guid> _equipmentInfoRepository;
        private readonly IRepository<EquipmentType, Guid> _equipmentTypeRepository;
        private readonly IRepository<ManufacturerInfo, Guid> _manufacturerInfoRepository;
        private readonly IRepository<TransformerSubstation, Guid> _transformerSubstationRepository;

        private readonly IRepository<ProtectionDeviceInfo, Guid> _protectionDeviceInfoRepository;
        private readonly IRepository<ProtectionDeviceHistory, Guid> _protectionDeviceHistoryRepository;
        private readonly IRepository<SecondaryCircuitProtectionDevice, Guid> _secondaryCircuitProtectionDeviceRepository;
        private readonly IRepository<BoardCardInfo, Guid> _boardCardInfoRepository;
        private readonly IRepository<BoardCardHistory, Guid> _boardCardHistoryRepository;
        private readonly IRepository<ImProtectDevice,string> _imProtectDeviceRepository;
        private readonly IRepository<ImGateWay, string> _imGateWayRepository;
        private readonly IRepository<ImPuCtgy, string> _imPuCtgyRepository;
        private readonly IRepository<ImEventType, int> _imEventTypeRepository;
        private readonly IRepository<TelemeteringConfiguration, Guid> _telemeteringConfigurationRepository;
        private readonly IRepository<TelesignalisationConfiguration, Guid> _telesignalisationConfigurationRepository;

        private readonly IRepository<ProtectionDeviceGateway, Guid> _protectionDeviceGatewayRepository;
        private readonly IRepository<ProtectionDeviceType, Guid> _protectionDeviceTypeyRepository;
        private readonly IRepository<ImDeviceDz, string> _imDeviceDzRepository;
        private readonly IRedisRepository<ImDeviceDzOutput, string> _imDeviceDzRedis;
        private readonly IUnitOfWorkManager _unitOfWorkManager;
        private readonly IRedisRepository<BCodeAndNTP, string> _bcodeAndNTP;
       public ProtectionDeviceAppService(
            IRepository<ProtectionDeviceInfo, Guid> protectionDeviceInfoRepository,
        IUnitOfWorkManager unitOfWorkManager,
        IRepository<ImProtectDevice, string> imProtectDeviceRepository,
        IRepository<EquipmentInfo, Guid> equipmentInfoRepository,
            IRepository<SecondaryCircuitProtectionDevice, Guid> secondaryCircuitProtectionDeviceRepository
             ,
            IRepository<TelemeteringConfiguration, Guid> telemeteringConfigurationRepository,
            IRepository<TelesignalisationConfiguration, Guid> telesignalisationConfigurationRepository,
            IRepository<ProtectionDeviceType, Guid> protectionDeviceTypeyRepository,
            IRepository<ImPuCtgy, string> imPuCtgyRepository,
            IRepository<ProtectionDeviceGateway, Guid> protectionDeviceGatewayRepository,
             IRepository<ImGateWay, string> imGateWayRepository,
          IRepository<BoardCardInfo, Guid> boardCardInfoRepository,
         IRepository<BoardCardHistory, Guid> boardCardHistoryRepository,
         IRepository<ProtectionDeviceHistory, Guid> protectionDeviceHistoryRepository,
         IRepository<EquipmentType, Guid> equipmentTypeRepository,
         IRepository<ManufacturerInfo, Guid> manufacturerInfoRepository,
         IRepository<TransformerSubstation, Guid> transformerSubstationRepository,
         IRepository<ImDeviceDz, string> imDeviceDzRepository,
         IRepository<ImEventType, int> imEventTypeRepository,
         IRedisRepository<BCodeAndNTP, string> bcodeAndNTP,
            ISessionAppService sessionAppService
            ) :
              base(sessionAppService)
        {
            _unitOfWorkManager = unitOfWorkManager;
            _equipmentInfoRepository = equipmentInfoRepository;
            _imProtectDeviceRepository = imProtectDeviceRepository;
            _protectionDeviceInfoRepository = protectionDeviceInfoRepository;
            _protectionDeviceHistoryRepository = protectionDeviceHistoryRepository;
            _boardCardInfoRepository = boardCardInfoRepository;
            _boardCardHistoryRepository = boardCardHistoryRepository;
            _secondaryCircuitProtectionDeviceRepository = secondaryCircuitProtectionDeviceRepository;
            _imGateWayRepository = imGateWayRepository;
            _protectionDeviceGatewayRepository = protectionDeviceGatewayRepository;
            _imPuCtgyRepository = imPuCtgyRepository;
            _protectionDeviceTypeyRepository = protectionDeviceTypeyRepository;
            _equipmentTypeRepository = equipmentTypeRepository;
            _manufacturerInfoRepository = manufacturerInfoRepository;
            _transformerSubstationRepository = transformerSubstationRepository;
            _imDeviceDzRepository = imDeviceDzRepository;
            _imEventTypeRepository = imEventTypeRepository;
            _telemeteringConfigurationRepository = telemeteringConfigurationRepository;
            _telesignalisationConfigurationRepository = telesignalisationConfigurationRepository;
            _bcodeAndNTP = bcodeAndNTP;
        }
        public async Task<RequestResult<ProtectionDeviceInfoViewOutput>> CreateOrUpdateAsync(EditProtectionDeviceInfoInput input)
        {
            RequestResult<ProtectionDeviceInfoViewOutput> rst = new RequestResult<ProtectionDeviceInfoViewOutput>();
            try
            {
                if (input.Id.HasValue)
                {
                    InsertUpdateRecord(input);
                   
                }
                else
                {
                    var entity = new ProtectionDeviceInfo();
                    entity.CreatorUserId = base.GetCurrentUser().Id;
                    entity.CreationTime = DateTime.Now;
                    // 逐字段赋值
                    entity.SeqNo = input.SeqNo;
                    entity.Name = input.Name;
                    entity.Specification = input.Specification;
                    entity.DeviceAddress = input.DeviceAddress;
                    entity.BaselineBoardVersion = input.BaselineBoardVersion;
                    entity.HardwareVersion = input.HardwareVersion;
                    entity.IsActive = input.IsActive;
                    entity.EquipmentInfo = new EquipmentInfo();
                    entity.EquipmentInfo.ManufacturerInfoId = input.ManufacturerInfoId;
                    entity.EquipmentInfo.SeqNo = input.SeqNo;
                    entity.EquipmentInfo.Name = input.Name;
                    entity.EquipmentInfo.InstallationDate = input.InstallationDate;
                    entity.EquipmentInfo.ProductionDate = input.ProductionDate;
                    entity.EquipmentInfo.FactorySerialNumber = input.FactorySerialNumber;
                    entity.EquipmentInfo.VerificationPerson = input.VerificationPerson;
                    entity.EquipmentInfo.VerificationDate = input.VerificationDate;
                    entity.EquipmentInfo.VerificationRecords = input.VerificationRecords;
                    entity.EquipmentInfo.ManufacturerInfoId = input.ManufacturerInfoId;
                    entity.EquipmentInfo.MaintenanceRecord = input.MaintenanceRecord;
                    var equipmentInfoId =await _equipmentInfoRepository.InsertAndGetIdAsync(entity.EquipmentInfo);
                    entity.EquipmentInfoId = equipmentInfoId;
                    var protectionDeviceInfo = await _protectionDeviceInfoRepository.InsertAsync(entity);
                    // 记录历史数据
                    var protectionDeviceHistory = new ProtectionDeviceHistory
                    {
                        Name = input.Name,
                        ProtectionDeviceInfoId = protectionDeviceInfo.Id,
                        RecodeDate = DateTime.Now,
                        ContentJson = "", // 原始数据
                        ContentNewJson = JsonConvert.SerializeObject(entity), // 新数据
                        EventDescription = "设备台账建立",
                        EventRecordType = EventRecordTypeEnum.Device,
                        IsSend = false  // 默认未发送
                    };
                    // 插入历史记录
                    _protectionDeviceHistoryRepository.Insert(protectionDeviceHistory);
                }
                rst.Flag = true;
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                rst.Flag = false;
                Log4Helper.Error(this.GetType(), "线路管理服务", ex);
            }

            return rst;
        }


        private void InsertUpdateRecord(EditProtectionDeviceInfoInput input)
        {
            if (input.Id.HasValue)
            {
                var entity = _protectionDeviceInfoRepository.GetAllIncluding(t => t.EquipmentInfo)
                                                              .FirstOrDefault(t => t.Id == input.Id);

                if (entity != null)
                {
                    // 记录更新前的数据
                    var originalContent = JsonConvert.SerializeObject(entity);

                    // 初始化事件描述
                    StringBuilder eventDescription = new StringBuilder("设备信息更新: ");

                    // 比较并更新字段
                    if (entity.SeqNo != input.SeqNo)
                    {
                        eventDescription.Append("顺序号更新, ");
                        entity.SeqNo = input.SeqNo;
                    }

                    if (entity.Name != input.Name)
                    {
                        eventDescription.Append($"设备名称更新：'{input.Name}', ");
                        entity.Name = input.Name;
                    }

                    if (entity.Specification != input.Specification)
                    {
                        eventDescription.Append($"规格更新：'{input.Specification}', ");
                        entity.Specification = input.Specification;
                    }

                    if (entity.DeviceAddress != input.DeviceAddress)
                    {
                        eventDescription.Append($"设备地址更新：'{input.DeviceAddress}', ");
                        entity.DeviceAddress = input.DeviceAddress;
                    }

                    if (entity.BaselineBoardVersion != input.BaselineBoardVersion)
                    {
                        eventDescription.Append($"基板版本更新：'{input.BaselineBoardVersion}', ");
                        entity.BaselineBoardVersion = input.BaselineBoardVersion;
                    }

                    if (entity.HardwareVersion != input.HardwareVersion)
                    {
                        eventDescription.Append($"硬件版本更新：'{input.HardwareVersion}', ");
                        entity.HardwareVersion = input.HardwareVersion;
                    }

                    if (entity.IsActive != input.IsActive)
                    {
                        eventDescription.Append($"启用状态更新：'{input.IsActive}', ");
                        entity.IsActive = input.IsActive;
                    }

                    // 设备信息赋值
                    if (entity.EquipmentInfo != null)
                    {
                        if (entity.EquipmentInfo.ManufacturerInfoId != input.ManufacturerInfoId)
                        {
                            eventDescription.Append($"制造商ID更新：'{input.ManufacturerInfoId}', ");
                            entity.EquipmentInfo.ManufacturerInfoId = input.ManufacturerInfoId;
                        }

                        if (entity.EquipmentInfo.Name != input.Name)
                        {
                            eventDescription.Append($"设备名称更新：'{input.Name}', ");
                            entity.EquipmentInfo.Name = input.Name;
                        }

                        if (entity.EquipmentInfo.InstallationDate != input.InstallationDate)
                        {
                            eventDescription.Append($"安装日期更新：'{input.InstallationDate}', ");
                            entity.EquipmentInfo.InstallationDate = input.InstallationDate;
                        }

                        if (entity.EquipmentInfo.ProductionDate != input.ProductionDate)
                        {
                            eventDescription.Append($"生产日期更新：'{input.ProductionDate}', ");
                            entity.EquipmentInfo.ProductionDate = input.ProductionDate;
                        }

                        if (entity.EquipmentInfo.FactorySerialNumber != input.FactorySerialNumber)
                        {
                            eventDescription.Append($"出厂序列号更新：'{input.FactorySerialNumber}', ");
                            entity.EquipmentInfo.FactorySerialNumber = input.FactorySerialNumber;
                        }

                        if (entity.EquipmentInfo.VerificationPerson != input.VerificationPerson)
                        {
                            eventDescription.Append($"验证人更新：'{input.VerificationPerson}', ");
                            entity.EquipmentInfo.VerificationPerson = input.VerificationPerson;
                        }

                        if (entity.EquipmentInfo.VerificationDate != input.VerificationDate)
                        {
                            eventDescription.Append($"验证日期更新：'{input.VerificationDate}', ");
                            entity.EquipmentInfo.VerificationDate = input.VerificationDate;
                        }

                        if (entity.EquipmentInfo.VerificationRecords != input.VerificationRecords)
                        {
                            eventDescription.Append($"验证记录更新：'{input.VerificationRecords}', ");
                            entity.EquipmentInfo.VerificationRecords = input.VerificationRecords;
                        }

                        if (entity.EquipmentInfo.MaintenanceRecord != input.MaintenanceRecord)
                        {
                            eventDescription.Append($"维修记录更新：'{input.MaintenanceRecord}', ");
                            entity.EquipmentInfo.MaintenanceRecord = input.MaintenanceRecord;
                        }
                    }

                    // 检查是否有变化并记录历史
                    var updatedContent = JsonConvert.SerializeObject(entity);

                    // 如果数据发生了变化，则记录历史
                    if (originalContent != updatedContent)
                    {
                        var history = new ProtectionDeviceHistory
                        {
                            ProtectionDeviceInfoId = entity.Id,
                            RecodeDate = DateTime.Now,
                            ContentJson = originalContent, // 记录更新前的内容
                            ContentNewJson = updatedContent, // 记录更新后的内容
                            EventDescription = eventDescription.ToString().TrimEnd(','),
                            EventRecordType = EventRecordTypeEnum.Device, // 假设更新：事件类型
                            Remark = "自动记录设备信息更新",
                            IsSend = false // 如果不需要立即发送给主站
                        };

                        // 保存历史记录
                        _protectionDeviceHistoryRepository.Insert(history);
                    }
                }
            }

        }
        /// <summary>
        /// 扫码枪输入设备信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [ShowApi]
        [AbpAllowAnonymous]
        [HttpPost]
        public RequestEasyResult ScanDeviceQRCode(EditProtectionQrCodeDeviceInfoInput input) 
        {
            RequestEasyResult rst = new RequestEasyResult();
            try
            {

                var repo = _protectionDeviceInfoRepository.GetAllIncluding(t => t.EquipmentInfo,t=>t.ProtectionDeviceType).ToList();

                var protectionDevice = repo.FirstOrDefault(t => t.Name.Contains(input.Name));
                if (protectionDevice != null) 
                {
                    //当出厂编号不一致进行履历更新
                    if (protectionDevice.EquipmentInfo.FactorySerialNumber != input.SerialNumber
                        || protectionDevice.EquipmentInfo.MaintenanceRecord!= input.MaintenanceRecord
                        || protectionDevice.EquipmentInfo.VerificationRecords != input.VerificationRecords
                        || protectionDevice.EquipmentInfo.VerificationDate != input.VerificationDate
                        || protectionDevice.EquipmentInfo.VerificationPerson!= input.VerificationPerson
                        || protectionDevice.EquipmentInfo.ProductionDate != input.ProductionDate
                        )
                    {
                        var json = JsonConvert.SerializeObject(protectionDevice);
                        var protectionDeviceHistory = _protectionDeviceHistoryRepository.GetAll().Where(t => t.ProtectionDeviceInfoId == protectionDevice.Id).ToList();
                        var deviceHistory = new ProtectionDeviceHistory
                        {
                            ContentJson = json,
                            CreationTime = DateTime.Now,
                            CreatorUserId = base.GetCurrentUser().Id,
                            Name = protectionDevice.Name,
                            RecodeDate = DateTime.Now,
                            ProtectionDeviceInfoId = protectionDevice.Id,
                            SeqNo = protectionDeviceHistory.Count > 0 ? protectionDeviceHistory.Max(t => t.SeqNo) : 1
                        };
                        protectionDevice.Specification = input.Specification;
                        protectionDevice.EquipmentInfo.FactorySerialNumber = input.SerialNumber;
                        protectionDevice.EquipmentInfo.ProductionDate = input.ProductionDate;
                        protectionDevice.EquipmentInfo.VerificationDate = input.VerificationDate;
                        protectionDevice.EquipmentInfo.VerificationPerson = input.VerificationPerson;
                        protectionDevice.EquipmentInfo.VerificationRecords = input.VerificationRecords;
                        var newjson = JsonConvert.SerializeObject(protectionDevice);
                        deviceHistory.ContentNewJson = newjson;
                        // 记录变更内容
                        var eventDescription = new StringBuilder();

                        // 通过判定每个字段是否发生变化，动态生成描述
                        if (protectionDevice.EquipmentInfo.FactorySerialNumber != input.SerialNumber)
                        {
                            eventDescription.AppendLine($"更换了设备的厂商序列号: {protectionDevice.EquipmentInfo.FactorySerialNumber} -> {input.SerialNumber}");
                        }
                        if (protectionDevice.EquipmentInfo.MaintenanceRecord != input.MaintenanceRecord)
                        {
                            eventDescription.AppendLine($"更新了设备的维修记录: {protectionDevice.EquipmentInfo.MaintenanceRecord} -> {input.MaintenanceRecord}");
                        }
                        if (protectionDevice.EquipmentInfo.VerificationRecords != input.VerificationRecords)
                        {
                            eventDescription.AppendLine($"更改了设备的检验记录: {protectionDevice.EquipmentInfo.VerificationRecords} -> {input.VerificationRecords}");
                        }
                        if (protectionDevice.EquipmentInfo.VerificationDate != input.VerificationDate)
                        {
                            eventDescription.AppendLine($"修改了设备的检验日期: {protectionDevice.EquipmentInfo.VerificationDate} -> {input.VerificationDate}");
                        }
                        if (protectionDevice.EquipmentInfo.VerificationPerson != input.VerificationPerson)
                        {
                            eventDescription.AppendLine($"更新了设备的检验人员: {protectionDevice.EquipmentInfo.VerificationPerson} -> {input.VerificationPerson}");
                        }
                        if (protectionDevice.EquipmentInfo.ProductionDate != input.ProductionDate)
                        {
                            eventDescription.AppendLine($"更改了设备的生产日期: {protectionDevice.EquipmentInfo.ProductionDate} -> {input.ProductionDate}");
                        }
                        deviceHistory.Name = protectionDevice.Name;
                        deviceHistory.EventDescription = eventDescription.ToString();
                        deviceHistory.EventRecordType  = EventRecordTypeEnum.Device;
                        deviceHistory.Remark = input.Remark;
                        _protectionDeviceHistoryRepository.Insert(deviceHistory);
                    }
                    rst.Flag = true;
                }
                else
                {
                    rst.Message = "未找到对应装置";
                }
                
            }
            catch (Exception  ex)
            {
                rst.Message = ex.Message;
            }

            return rst;
        }
       
        public async Task<RequestEasyResult> DeleteByIdAsync(Guid id)
        {
            RequestEasyResult rst = new RequestEasyResult();
            return rst;
        }

        public async Task<RequestEasyResult> DeleteByIdsAsync(List<Guid> ids)
        {
            RequestEasyResult rst = new RequestEasyResult();
            return rst;
        }
        /// <summary>
        /// 查询保护装置信息
        /// </summary>
        /// <param name="searchCondition"></param>
        /// <returns></returns>
        [ShowApi]
        [AbpAllowAnonymous]
        [DisableAuditing]
        [HttpPost]
        public RequestPageResult<ProtectionDeviceInfoViewOutput> FindDatas(PageSearchCondition<ProtectionDeviceInfoSearchConditionInput> searchCondition)
        {
            RequestPageResult<ProtectionDeviceInfoViewOutput> rst = new RequestPageResult<ProtectionDeviceInfoViewOutput>();

            try
            {
                var repo = _protectionDeviceInfoRepository.GetAllIncluding(t => t.EquipmentInfo)
                    .WhereIf(searchCondition.SearchCondition.IsOnlyActive.HasValue, t => t.IsActive)
                    .WhereIf(searchCondition.SearchCondition.Id.HasValue, t => t.Id == searchCondition.SearchCondition.Id.Value)
                    .WhereIf(searchCondition.SearchCondition.TransformerSubstationId.HasValue, t => t.Id == searchCondition.SearchCondition.TransformerSubstationId.Value).ToList();
                List<ProtectionDeviceInfoViewOutput> datas = default;
                if (!string.IsNullOrWhiteSpace( searchCondition.SearchCondition.Name))
                {
                    repo = repo.Where(t => t.Name.Contains(searchCondition.SearchCondition.Name)).ToList();
                }
                rst.TotalCount = repo.Count();
                if (repo.Count()>0)
                {
                    rst.PageSize = searchCondition.PageSize;
                    rst.PageIndex = searchCondition.PageIndex;
                    if ( searchCondition.PageSize>0)
                    {
                        var  dataTemps = repo.Skip((searchCondition.PageIndex-1)* searchCondition.PageSize).Take(searchCondition.PageSize);
                        datas = ObjectMapper.Map<List<ProtectionDeviceInfoViewOutput>>(dataTemps);
                    }
                    else
                    {
                        datas = ObjectMapper.Map<List<ProtectionDeviceInfoViewOutput>>(repo);
                    }
                }
                
                rst.ResultData= datas;
                rst.Flag = true;
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                rst.Flag = false;
                Log4Helper.Error(this.GetType(), "保护装置信息管理服务", ex);
            }

            return rst;
        }

        /// <summary>
        /// 查询保护装置信息
        /// </summary>
        /// <param name="searchCondition"></param>
        /// <returns></returns>
        [ShowApi]
        [AbpAllowAnonymous]
        [DisableAuditing]
        [HttpPost]
        public RequestPageResult<ProtectionDeviceInfoViewOutput> FindDatasByCircuit(PageSearchCondition<ProtectionDeviceInfoSearchConditionInput> searchCondition)
        {
            RequestPageResult<ProtectionDeviceInfoViewOutput> rst = new RequestPageResult<ProtectionDeviceInfoViewOutput>();

            try
            {
                var repo = _secondaryCircuitProtectionDeviceRepository.GetAllIncluding(t => t.ProtectionDevice)
                    .Where(t=>t.SecondaryCircuitId == searchCondition.SearchCondition.SecondaryCircuitId).ToList();
                List<ProtectionDeviceInfoViewOutput> datas = default;
                
                rst.TotalCount = repo.Count();
                if (repo.Count() > 0)
                {
                    rst.PageSize = searchCondition.PageSize;
                    rst.PageIndex = searchCondition.PageIndex;
                    if (searchCondition.PageSize > 0)
                    {
                        var dataTemps = repo.Skip((searchCondition.PageIndex - 1) * searchCondition.PageSize).Take(searchCondition.PageSize);
                        datas = ObjectMapper.Map<List<ProtectionDeviceInfoViewOutput>>(dataTemps.Select(t=>t.ProtectionDevice));
                    }
                    else
                    {
                        datas = ObjectMapper.Map<List<ProtectionDeviceInfoViewOutput>>(repo);
                    }
                }

                rst.ResultData = datas;
                rst.Flag = true;
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                rst.Flag = false;
                Log4Helper.Error(this.GetType(), "保护装置信息管理服务", ex);
            }

            return rst;
        }

        /// <summary>
        /// 查询保护装置信息
        /// </summary>
        /// <param name="equipmentInfoId"></param>
        /// <returns></returns>
        [ShowApi]
        [AbpAllowAnonymous]
        [DisableAuditing]
        [HttpGet]
        public RequestResult<ProtectionDeviceInfoViewOutput> FindDataByEquipmentInfoId(Guid? equipmentInfoId)
        {
            RequestResult<ProtectionDeviceInfoViewOutput> rst = new RequestResult<ProtectionDeviceInfoViewOutput>();

            try
            {
                var entity = _protectionDeviceInfoRepository.GetAllIncluding(t => t.EquipmentInfo,t=>t.EquipmentInfo.ManufacturerInfo)
                        .FirstOrDefault(t => t.EquipmentInfoId == equipmentInfoId);
                if (entity!=null)
                {
                    rst.ResultData = ObjectMapper.Map<ProtectionDeviceInfoViewOutput>(entity); 
                    rst.Flag = true;
                }
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                rst.Flag = false;
                Log4Helper.Error(this.GetType(), "保护装置信息管理服务", ex);
            }

            return rst;
        }
       
        /// <summary>
        /// 查询历史保护装置信息
        /// </summary>
        /// <param name="equipmentInfoId"></param>
        /// <returns></returns>
        [ShowApi]
        [AbpAllowAnonymous]
        [DisableAuditing]
        [HttpGet]
        public RequestResult<List<ProtectionDeviceHistoryOutput>> FindHistoryDataByEquipmentInfoId(Guid? equipmentInfoId)
        {
            RequestResult<List<ProtectionDeviceHistoryOutput>> rst = new RequestResult<List<ProtectionDeviceHistoryOutput>>();
            try
            {
                List<ProtectionDeviceHistoryOutput> historys = new List<ProtectionDeviceHistoryOutput>();
                var protectionDevice = _protectionDeviceInfoRepository.GetAllIncluding(t => t.EquipmentInfo)
                        .FirstOrDefault(t => t.EquipmentInfoId == equipmentInfoId);
                if (protectionDevice != null)
                {
                    var entitys = _protectionDeviceHistoryRepository.GetAll()
                        .Where(t => t.ProtectionDeviceInfoId == protectionDevice.Id)
                        .OrderByDescending(t=>t.RecodeDate)
                        ;
                    historys = ObjectMapper.Map<List<ProtectionDeviceHistoryOutput>>(entitys);
                    rst.Flag = true;
                    rst.ResultData = historys;
                }
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                rst.Flag = false;
                Log4Helper.Error(this.GetType(), "保护装置信息管理服务", ex);
            }

            return rst;
        }
        public RequestResult<string> GetProtectionDeviceQRcode(Guid id)
        {
            RequestResult<string> rst = new RequestResult<string>();
            return rst;
        }


        /// <summary>
        /// 获取保护装置列表
        /// </summary>
        /// <param name="stationId"></param>
        /// <returns></returns>
        [HttpGet]
        [ShowApi]
        [AbpAllowAnonymous]
        [DisableAuditing]
        public RequestResult<List<SelectModelOutput>> FindProtectionDeviceForSelect(Guid stationId)
        {
            var rst = new RequestResult<List<SelectModelOutput>> { Flag = false };
            try
            {
                var datas = _protectionDeviceInfoRepository.GetAllIncluding()
                    .Where(e => e.IsActive)
                    .Where(t=>t.TransformerSubstationId == stationId)
                    .OrderBy(x=>x.SeqNo).ThenBy(x => x.Name);
               
                rst.ResultData = datas.Select(item => new SelectModelOutput
                {
                    Value = item.Id.ToString().ToLower(),
                    Key = item.Id,
                    Text = item.Name
                }).ToList();

                rst.Flag = true;
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                rst.Flag = false;
                Log4Helper.Error(this.GetType(), "获取保护装置列表", ex);
            }

            return rst;
        }
        /// <summary>
        /// 只在所内有效-获取变电所装置的ip地址
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [ShowApi]
        [AbpAllowAnonymous]
        [UnitOfWork(false)]
        public RequestResult<List<ProtectionDeviceCommInfoOutput>> FindProtectionDeviceCommInfo(string stationName)
        {
            RequestResult<List<ProtectionDeviceCommInfoOutput>> rst = new RequestResult<List<ProtectionDeviceCommInfoOutput>>();
            try
            {
                Dictionary<string, ProtectionDeviceInfo> porotectionDeviceInfos = default;
                using (var unitOfWork = _unitOfWorkManager.Begin())
                {
                    porotectionDeviceInfos = _protectionDeviceInfoRepository.GetAllIncluding().Where(t=>t.IsActive).ToDictionary(t => t.ISMS_DeviceId);
                    unitOfWork.Complete();
                }
                using (var unitOfWork = _unitOfWorkManager.Begin())
                {
                    var devices = _imProtectDeviceRepository.GetAllIncluding(t => t.StatCodeNavigation, t => t.GateWay, t => t.PuctgyCodeNavigation).OrderBy(t => t.DeviceAddr);
                    List<ProtectionDeviceCommInfoOutput> datas = new List<ProtectionDeviceCommInfoOutput>();
                    foreach (var item in devices)
                    {
                        if (!porotectionDeviceInfos.ContainsKey(item.Id))
                        {
                            continue;
                        }
                        var deviceCommInfo = new ProtectionDeviceCommInfoOutput
                        {
                            EquipmentInfoName = porotectionDeviceInfos[item.Id].Name,
                            EquipmentInfoId = porotectionDeviceInfos[item.Id].EquipmentInfoId,
                            ProtectionDeviceId = porotectionDeviceInfos[item.Id].Id,
                            DeviceAddr = item.DeviceAddr,
                            DeviceName = item.DeviceName,
                            GatewayIP1 = item.GateWay.GatewayIp1,
                            GatewayIP2 = item.GateWay.GatewayIp2,
                            GatewayIP3 = "",
                            MaskEth1 = "255.255.255.0",
                            MaskEth2 = "255.255.255.0",
                            MaskEth3 = "255.255.255.0",
                            Gateway = "192.168.61.1",
                            Sntp1 = "192.168.61.99",
                            Sntp2 = "192.168.61.99",
                            IsZY = item.PuctgyCodeNavigation.PuctgyName.Contains("站域")
                        };
                        datas.Add(deviceCommInfo);
                    }
                    rst.ResultData = datas;
                    unitOfWork.Complete();

                }
               
                rst.Flag = true;
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                rst.Flag = false;
                Log4Helper.Error(this.GetType(), "保护装置信息管理服务", ex);
            }
            return rst;
        }
        /// <summary>
        /// 根据装置id获取装置通信参数
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [ShowApi]
        [AbpAllowAnonymous]
        [UnitOfWork(false)]
        public async Task<RequestResult<ProtectionDeviceCommInfoOutput>> GetProtectionDeviceCommInfo(Guid deviceId,Guid equipmentId)
        {
            RequestResult<ProtectionDeviceCommInfoOutput> rst = new RequestResult<ProtectionDeviceCommInfoOutput>();
            try
            {

               
                ProtectionDeviceInfo protectionDeviceInfo = null;
                using (var work = _unitOfWorkManager.Begin())
                {
                    if (deviceId == default)
                    {
                        protectionDeviceInfo = _protectionDeviceInfoRepository.GetAll().FirstOrDefault(t=>t.EquipmentInfoId == equipmentId);
                    }
                    else 
                    {
                        protectionDeviceInfo = _protectionDeviceInfoRepository.Get(deviceId);
                    }
                    await work.CompleteAsync();
                }
                if (protectionDeviceInfo==null)
                {
                    rst.Message = "传输id错误";
                    return rst;
                }
                ImProtectDevice device = null;
                using (var work = _unitOfWorkManager.Begin())
                {
                    device = _imProtectDeviceRepository.GetAllIncluding(t => t.StatCodeNavigation, t => t.GateWay).FirstOrDefault(t=>t.Id == protectionDeviceInfo.ISMS_DeviceId);
                    await work.CompleteAsync();
                }
                if (device!=null)
                {
                    var deviceCommInfo = new ProtectionDeviceCommInfoOutput
                    {
                        DeviceAddr = device.DeviceAddr,
                        DeviceName = device.DeviceName,
                        GatewayIP1 = device.GateWay.GatewayIp1,
                        GatewayIP2 = device.GateWay.GatewayIp2,
                        GatewayIP3 = "",
                        MaskEth1 = "",
                        MaskEth2 = "",
                        MaskEth3 = "",
                        Gateway = "t192.168.61.1",
                        Sntp1 = "192.168.61.99",
                        Sntp2 = "192.168.61.99"
                    };

                    rst.ResultData = deviceCommInfo;
                }
                rst.Flag = true;
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                rst.Flag = false;
                Log4Helper.Error(this.GetType(), "保护装置信息管理服务", ex);
            }
            return rst;
        }
        
        
        /// <summary>
        /// 从综自后台数据库迁移数据到运维数据库中（保护装置数据）
        /// </summary>
        /// <returns></returns>
        [ShowApi]
        [AbpAllowAnonymous]
        [HttpGet]
        [UnitOfWork(isTransactional: false)]
        public RequestEasyResult MigreteDeviceEquipementDataFromISMS()
        {
            RequestEasyResult rst = new RequestEasyResult();
            try
            {
                Dictionary<string,EquipmentInfo> equipments = default;
                Dictionary<string, ImProtectDevice> imProtectDevices = default;
                Dictionary<string, ProtectionDeviceInfo> porotectionDeviceInfos = default;
                EquipmentType equipmentType = default;
                ManufacturerInfo manufacturerInfo = default;
                TransformerSubstation transformerSubstation = default;
                using (var unitOfWork = _unitOfWorkManager.Begin())
                {
                    transformerSubstation = _transformerSubstationRepository.GetAll().First();
                    equipments = _equipmentInfoRepository.GetAllIncluding().ToDictionary(t => t.Name);
                    equipmentType = _equipmentTypeRepository.GetAll().FirstOrDefault(t => t.Name.Contains("保护装置"));
                    manufacturerInfo = _manufacturerInfoRepository.GetAll().FirstOrDefault(t => t.ManufacturerName.Contains("运达"));
                    porotectionDeviceInfos = _protectionDeviceInfoRepository.GetAllIncluding().ToDictionary(t=>t.Name);
                    unitOfWork.Complete();
                }
                using (var unitOfWork = _unitOfWorkManager.Begin())
                {
                    imProtectDevices = _imProtectDeviceRepository.GetAllIncluding().ToDictionary(t => t.DeviceName);
                    unitOfWork.Complete();

                }
                int count = 0;
                using (var unitOfWork = _unitOfWorkManager.Begin())
                {
                    foreach (var item in imProtectDevices.Keys)
                    {
                        var imProtectDevice = imProtectDevices[item];
                        Guid equipmentInfoId = default;
                        if (!equipments.ContainsKey(item))
                        {
                            var equipmentinfo = new EquipmentInfo
                            {
                                SeqNo = imProtectDevice.DeviceAddr,
                                TransformerSubstationId = transformerSubstation.Id,
                                CreationTime = DateTime.Now,
                                CreatorUserId = null,
                                IsActive = true,
                                EquipmentTypeId = equipmentType.Id,
                                ManufacturerInfoId = manufacturerInfo.Id,
                                Name = item
                            };
                            equipmentInfoId = _equipmentInfoRepository.InsertAndGetId(equipmentinfo);
                        }
                        else {
                            equipmentInfoId = equipments[item].Id;
                        }
                        if (!porotectionDeviceInfos.ContainsKey(item))
                        {
                            ProtectionDeviceInfo protectionDeviceInfo = new ProtectionDeviceInfo()
                            {
                                CanSwitchDZZone = imProtectDevice.CanSwDzzone == 1 ? true : false,
                                CreationTime = DateTime.Now,
                                CreatorUserId = null,
                                SupportsDualCurrent = imProtectDevice.SupportVersion,
                                BayName = imProtectDevice.BayName,
                                DeviceAddress = imProtectDevice.DeviceAddr,
                                DeviceState = imProtectDevice.DeviceState,
                                EndOfDKJL = imProtectDevice.EndOfDkjl,
                                EquipmentInfoId = equipmentInfoId,
                                IsActive = true,
                                ISMS_DeviceId = imProtectDevice.Id,
                                Name = item,
                                ProtectionDeviceGatewayId = null,
                                ProtectionDeviceTypeId = null,
                                TransformerSubstationId = transformerSubstation.Id,
                            };
                            _protectionDeviceInfoRepository.Insert(protectionDeviceInfo);
                            // 记录历史数据
                            var protectionDeviceHistory = new ProtectionDeviceHistory
                            {
                                Name = item,
                                ProtectionDeviceInfoId = protectionDeviceInfo.Id,
                                RecodeDate = DateTime.Now,
                                ContentJson = "", // 原始数据
                                ContentNewJson = JsonConvert.SerializeObject(protectionDeviceInfo), // 新数据
                                EventDescription = "设备台账建立",
                                EventRecordType = EventRecordTypeEnum.Device,  
                                IsSend = false  // 默认未发送
                            };
                            // 插入历史记录
                            _protectionDeviceHistoryRepository.Insert(protectionDeviceHistory);
                        }
                        else
                        {
                            porotectionDeviceInfos[item].DeviceAddress = imProtectDevice.DeviceAddr;
                        }
                    }
                    unitOfWork.Complete();
                }
                rst.Flag = true;
                rst.Message = $"共完成{count}信息迁移";
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                rst.Flag = false;
                Log4Helper.Error(this.GetType(), "线路管理服务", ex);
            }

            return rst;
        }
        /// <summary>
        /// 从综自后台数据库迁移数据到运维数据库中（保护装置类型数据）
        /// </summary>
        /// <returns></returns>
        [ShowApi]
        [AbpAllowAnonymous]
        [HttpGet]
        [UnitOfWork(isTransactional: false)]
        public RequestEasyResult MigreteImProtectionDeviceTypeDataFromISMS()
        {
            RequestEasyResult rst = new RequestEasyResult();
            try
            {
                Dictionary<string,ProtectionDeviceType> protectionDeviceTypes = default;
                List<ImPuCtgy> imPuCtgies = default;
                using (var unitOfWork = _unitOfWorkManager.Begin())
                {
                    protectionDeviceTypes = _protectionDeviceTypeyRepository.GetAll().ToDictionary(t=>t.Name);
                    unitOfWork.Complete();
                }
                using (var unitOfWork = _unitOfWorkManager.Begin())
                {
                    imPuCtgies = _imPuCtgyRepository.GetAll().ToList();
                    unitOfWork.Complete();
                }
                using (var unitOfWork = _unitOfWorkManager.Begin())
                {
                    // 提前获取已经存在的保护设备类型名称，避免每次循环都查询
                    var existingProtectionDeviceTypes = _protectionDeviceTypeyRepository
                        .GetAll()
                        .Where(t => imPuCtgies.Select(im => im.PuctgyName).Contains(t.Name))
                        .ToDictionary(t => t.Name, t => t);

                    // 创建一个 ProtectionDeviceType 的集合来批量插入
                    var protectionDeviceTypesToInsert = new List<ProtectionDeviceType>();

                    foreach (var imPuCtgie in imPuCtgies)
                    {
                        // 检查该类型是否已经存在
                        if (existingProtectionDeviceTypes.ContainsKey(imPuCtgie.PuctgyName))
                        {
                            continue;
                        }

                        // 创建新的 ProtectionDeviceType 对象
                        var protectionDeviceType = new ProtectionDeviceType
                        {
                            CanSwitchDZZone = false,
                            CreationTime = DateTime.Now,
                            CreatorUserId = base.GetCurrentUser().Id,
                            DZZoneCount = imPuCtgie.DzzoneCount,
                            IsCRCC = true,
                            PUCtgyCode = 0,
                            Support12YC = false,
                            AnalogParseMode = imPuCtgie.AnalogParseMode,
                            DZReadOnly = false,
                            EventParseMode = imPuCtgie.EventParseMode,
                            IsActive = true,
                            ManufacturerInfoId = default,
                            Model = imPuCtgie.Model,
                            Name = imPuCtgie.PuctgyName,
                            Generation = imPuCtgie.Generation,
                        };

                        // 添加到集合中，准备批量插入
                        protectionDeviceTypesToInsert.Add(protectionDeviceType);
                    }

                    // 批量插入新记录
                    if (protectionDeviceTypesToInsert.Any())
                    {
                        _protectionDeviceTypeyRepository.InsertRange(protectionDeviceTypesToInsert);
                    }

                    // 提交事务
                    unitOfWork.Complete();
                }

                rst.Flag = true;

            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                rst.Flag = false;
                Log4Helper.Error(this.GetType(), "线路管理服务", ex);
            }

            return rst;
        }
        /// <summary>
        /// 从综自后台数据库迁移数据到运维数据库中（保护装置网关数据）
        /// </summary>
        /// <returns></returns>
        [ShowApi]
        [AbpAllowAnonymous]
        [HttpGet]
        [UnitOfWork(isTransactional: false)]
        public RequestEasyResult MigreteImGatewayDataFromISMS()
        {
            RequestEasyResult rst = new RequestEasyResult();
            try
            {
                Dictionary<string, ImProtectDevice> imProtectDevices = default;
                Dictionary<string, ProtectionDeviceInfo> porotectionDeviceInfos = default;
                //Dictionary<string, ImGateWay> imGateWays = default;

                using (var unitOfWork = _unitOfWorkManager.Begin())
                {
                    porotectionDeviceInfos = _protectionDeviceInfoRepository.GetAllIncluding(t=>t.EquipmentInfo).ToDictionary(t => t.Name);
                    unitOfWork.Complete();
                }
                using (var unitOfWork = _unitOfWorkManager.Begin())
                {
                    imProtectDevices = _imProtectDeviceRepository.GetAllIncluding(t=>t.GateWay,t=>t.PuctgyCodeNavigation).ToDictionary(t => t.DeviceName);
                    unitOfWork.Complete();

                }
                int count = 0;
                using (var unitOfWork = _unitOfWorkManager.Begin())
                {
                    foreach (var device in imProtectDevices.Keys)
                    {
                        var porotectionDevice =  porotectionDeviceInfos[device];
                        var imProtectDevice = imProtectDevices[device];
                        if (porotectionDevice != null)
                        {
                            ProtectionDeviceGateway protectionDeviceGateway = new ProtectionDeviceGateway
                            {
                                CreationTime = DateTime.Now,
                                CreatorUserId = base.GetCurrentUser().Id,
                                GatewayIP1 = imProtectDevice.GateWay.GatewayIp1,
                                GatewayIP2 = imProtectDevice.GateWay.GatewayIp2,
                                GatewayPort1 = imProtectDevice.GateWay.GatewayPort1,
                                GatewayPort2 = imProtectDevice.GateWay.GatewayPort2,
                                IsActive = true,
                                Name = imProtectDevice.GateWay.GateWayName,
                                PhysicalAddress = imProtectDevice.GateWay.PhyAddr,
                                Protocol = imProtectDevice.GateWay.Protocol,
                                TransformerSubstationId = porotectionDevice.TransformerSubstationId,
                                ProtectionDeviceInfoId = porotectionDevice.Id
                            };
                            ProtectionDeviceType protectionDeviceType = new ProtectionDeviceType
                            {
                                CanSwitchDZZone = false,
                                CreationTime = DateTime.Now,
                                CreatorUserId = base.GetCurrentUser().Id,
                                DZZoneCount = imProtectDevice.PuctgyCodeNavigation.DzzoneCount,
                                IsCRCC = true,
                                PUCtgyCode = imProtectDevice.PuctgyCode,
                                Support12YC = false,
                                AnalogParseMode = imProtectDevice.PuctgyCodeNavigation.AnalogParseMode,
                                DZReadOnly = false,
                                EventParseMode = imProtectDevice.PuctgyCodeNavigation.EventParseMode,
                                IsActive = true,
                                ManufacturerInfoId = porotectionDevice.EquipmentInfo.ManufacturerInfoId,
                                Model = imProtectDevice.PuctgyCodeNavigation.Model,
                                Name = imProtectDevice.PuctgyCodeNavigation.PuctgyName,
                                Generation = imProtectDevice.PuctgyCodeNavigation.Generation,
                            };
                            _protectionDeviceTypeyRepository.Insert(protectionDeviceType);
                            _protectionDeviceGatewayRepository.Insert(protectionDeviceGateway);
                        }
                    }
                    unitOfWork.Complete();
                }
                rst.Flag = true;
                rst.Message = $"共完成{count}信息迁移";
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                rst.Flag = false;
                Log4Helper.Error(this.GetType(), "线路管理服务", ex);
            }

            return rst;
        }
        /// <summary>
        /// 获取装置事件类型
        /// </summary>
        /// <param name="deviceAddr"></param>
        /// <param name="eventCode"></param>
        /// <returns></returns>
        [ShowApi]
        [AbpAllowAnonymous]
        [HttpGet]
        [DisableAuditing]

        public RequestResult<EquipmentInfoAbnormalComponent> GetDeviceEventType(int deviceAddr,int eventCode)
        {
            RequestResult <EquipmentInfoAbnormalComponent> rst= new RequestResult<EquipmentInfoAbnormalComponent>();
            try
            {
                var device = _imProtectDeviceRepository.GetAll().FirstOrDefault(t => t.DeviceAddr == deviceAddr);
                if (device!=null)
                {
                    var imEvent =  _imEventTypeRepository.GetAll().FirstOrDefault(t=>t.Id == eventCode&&t.PuctgyCode == device.PuctgyCode);
                    if (imEvent!=null)
                    {
                        EquipmentInfoAbnormalComponent abnormalComponent = new EquipmentInfoAbnormalComponent()
                        {
                            ComponentName = device.DeviceName,
                            AbnormalReason = imEvent.EvtName,
                            HandlingMeasures ="",
                        };
                        rst.ResultData = abnormalComponent;
                        rst.Flag = true;
                    }
                }
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message; 
                Log4Helper.Error(this.GetType(), "获取装置事件类型", ex);
            }
            return rst;
        }
        /// <summary>
        /// 获取装置状态
        /// </summary>
        /// <param name="equipmentInfoId"></param>
        /// <returns></returns>
        [ShowApi]
        [AbpAllowAnonymous]
        [HttpGet]
        [DisableAuditing]
        [UnitOfWork(isTransactional: false)]

        public async Task<RequestResult<DeviceStatus>> GetDeviceStatusAsync(Guid equipmentInfoId)
        {
            RequestResult<DeviceStatus> rst = new RequestResult<DeviceStatus>();
            try
            {
                ProtectionDeviceInfo protectionDeviceInfo = default;
                using (var unitOfWork = _unitOfWorkManager.Begin())
                {
                    protectionDeviceInfo = _protectionDeviceInfoRepository.GetAllIncluding(t=>t.EquipmentInfo).FirstOrDefault(t=>t.EquipmentInfoId == equipmentInfoId);
                    await unitOfWork.CompleteAsync();
                }
                if (protectionDeviceInfo != null)
                {
                    
                    using (var unitOfWork = _unitOfWorkManager.Begin())
                    {
                        var device = _imProtectDeviceRepository.GetAllIncluding(t=>t.GateWay).FirstOrDefault(t => t.Id == protectionDeviceInfo.ISMS_DeviceId);
                        if (device != null)
                        {
                            DeviceStatus deviceStatus = new DeviceStatus()
                            {
                                ConnectionStatus104=0,
                                EquipmentInfoId = equipmentInfoId,
                                EquipmentInfoName = protectionDeviceInfo.EquipmentInfo.Name,
                                FreeMemory = "0KB",
                                UsedMemory ="0KB",
                                LcdOperationPassword ="",
                                ProtectionDeviceId = protectionDeviceInfo.Id,
                                TotalDisk = "0M",
                                UsedDisk ="0M",
                                NetworkInterfaces = new List<NetworkInterfaceStatus>
                                {
                                    new NetworkInterfaceStatus
                                    {
                                        IpAddress =device.GateWay.GatewayIp1,
                                        InterfaceName ="eth0",
                                    },
                                     new NetworkInterfaceStatus
                                    {
                                        IpAddress =device.GateWay.GatewayIp2,
                                        InterfaceName ="eth1",
                                    },
                                      new NetworkInterfaceStatus
                                    {
                                        IpAddress ="",
                                        InterfaceName ="eth2",
                                    },
                                }
                            };
                            rst.ResultData = deviceStatus;
                            rst.Flag = true;
                        }
                        await unitOfWork.CompleteAsync();
                    }
                }
                
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                Log4Helper.Error(this.GetType(), "线路管理服务", ex);
            }
            return rst;
        }
        /// <summary>
        /// 根据关键字获取保护装置的遥信遥测
        /// </summary>
        /// <param name="equipmentInfoId"></param>
        /// <param name="keyword"></param>
        /// <returns></returns>
        [ShowApi]
        [AbpAllowAnonymous]
        [HttpGet]
        [DisableAuditing]
        public async Task<RequestResult<List<TelemeteringConfigurationProperty>>> GetTelemeteringByKeywordAsync(Guid equipmentInfoId,string keyword)
        {
            RequestResult<List<TelemeteringConfigurationProperty>> rst = new();

            try
            {
                if (equipmentInfoId!=default&&!string.IsNullOrWhiteSpace(keyword))
                {
                    var repo =(await _telemeteringConfigurationRepository.GetAllIncludingAsync())
                     .Where(t => t.EquipmentInfoId == equipmentInfoId).ToList();
                    var data = repo.Where(t => t.Name.ToLower().Contains(keyword.ToLower()));
                    rst.ResultData = ObjectMapper.Map<List<TelemeteringConfigurationProperty>>(data);
                    rst.Flag = true;
                }
                    //.Where(t=>t.Name.Contains())
            }
            catch (Exception ex)
            {
                Log4Helper.Error(this.GetType(), "线路管理服务", ex);
            }
            return rst;
        }
        /// <summary>
        /// 获取装置初始监测状态
        /// </summary>
        /// <param name="equipmentInfoId"></param>
        /// <returns></returns>
        [AbpAllowAnonymous]
        [HttpGet]
        [DisableAuditing]
        public async Task<RequestResult<DeviceCPUMonitoring>> GetDeviceCPUMonitoring(Guid equipmentInfoId)
        {
            RequestResult<DeviceCPUMonitoring> rst = new();
            try
            {
                rst.ResultData = new DeviceCPUMonitoring
                {
                    EquipmentInfoId = equipmentInfoId,
                    CPU5V1 = 5f,
                    CPU5V2 = 5f,
                    CPU5V3 = 5f,
                    CPUTemperature = 0,
                    SurfaceTemperature = 0,
                    Time = DateTime.Now,
                };
                rst.Flag = true;
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;

                Log4Helper.Error(this.GetType(), "线路管理服务", ex);
            }
            return rst;
        }
        [AbpAllowAnonymous]
        [HttpGet]
        [DisableAuditing]
        public async Task<RequestResult<BCodeAndNTP>> GetDeviceBCondeAndNTP(Guid equipmentInfoId)
        {
            RequestResult<BCodeAndNTP> rst = new();
            try
            {
                var device = _protectionDeviceInfoRepository.GetAll().FirstOrDefault(t => t.EquipmentInfoId == equipmentInfoId);
                if (device!=null)
                {
                    var entity =await _bcodeAndNTP.HashSetGetOneAsync(nameof(BCodeAndNTP), device.DeviceAddress.ToString());
                    rst.ResultData = entity;
                    rst.Flag = true;
                }
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;

                Log4Helper.Error(this.GetType(), "线路管理服务", ex);
            }
            return rst;
        }
#if DEBUG
        /// <summary>
        /// 填充出厂编号
        /// </summary>
        /// <returns></returns>
        [ShowApi]
        [AbpAllowAnonymous]
        [HttpGet]
        public  RequestEasyResult UpdateProtetionInfoForTest()
        {
            RequestEasyResult rst = new RequestEasyResult();
            try
            {
                var datas =  _protectionDeviceInfoRepository.GetAllIncluding(t => t.EquipmentInfo);
                Random random = new Random();
                foreach (var data in datas) {

                    data.BaselineBoardVersion = "v1.100.001";
                    data.Specification = "110V 1A";
                    data.EquipmentInfo.FactorySerialNumber = "210"+ random.Next(100000, 1000000).ToString();
                    // 设置出厂时间：当前日期的前一天（您可以根据需求调整时间）
                    data.EquipmentInfo.ProductionDate = DateTime.Now.AddDays(-100);
                    // 设置检验人员
                    data.EquipmentInfo.VerificationPerson = "贺严玲"; // 请替换：实际人员名称
                    // 设置检验日期：当前日期
                    data.EquipmentInfo.VerificationDate = DateTime.Now.AddDays(0).ToString("yyyy-MM-dd"); // 日期格式： "yyyy-MM-dd"
                    // 设置检验记录内容
                    data.EquipmentInfo.VerificationRecords = "检验装置外观及功能，均符合要求";

                }
            }
            catch (Exception ex)
            {

                throw;
            }
            return rst;
        }
        /// <summary>
        /// 填充出厂编号
        /// </summary>
        /// <returns></returns>
        [ShowApi]
        [AbpAllowAnonymous]
        [HttpGet]
        public async Task<RequestEasyResult> UpdateProtetionInfoForHistoryTest()
        {
            RequestEasyResult rst = new RequestEasyResult();
            try
            {
                List<ProtectionDeviceInfo> datas;
                using (var unitOfWork = _unitOfWorkManager.Begin())
                {
                    datas = _protectionDeviceInfoRepository.GetAllIncluding(t => t.EquipmentInfo).ToList();
                    await unitOfWork.CompleteAsync();
                }
                Random random = new Random();
                for (int i = 0; i < 3; i++)
                {
                    foreach (var data in datas)
                    {
                        EditProtectionQrCodeDeviceInfoInput deviceInfo = new EditProtectionQrCodeDeviceInfoInput
                        {
                            Name = data.Name,                     // 示例装置名称
                            SerialNumber = "210" + random.Next(100000, 1000000).ToString(), // 出厂编号设： "210" 开头 + 6 位随机数
                            ProductionDate = new DateTime(2023, 5, 15),        // 示例生产日期
                            VerificationPerson = "贺严玲",                        // 示例检验人员
                            VerificationDate = DateTime.Now.AddDays(-100+i).ToString("yyyy-MM-dd"), // 检验日期设：当前日期
                            VerificationRecords = "检验装置外观及功能，均符合要求"   // 示例检验记录
                        };
                        using (var unitOfWork = _unitOfWorkManager.Begin())
                        {
                            ScanDeviceQRCode(deviceInfo);
                            await unitOfWork.CompleteAsync();

                        }
                    }
                }
               
            }
            catch (Exception ex)
            {

                throw;
            }



            return rst;
        }

#endif
        /// <summary>
        /// 生成装置的初始历史记录
        /// </summary>
        /// <returns></returns>
        [ShowApi]
        [AbpAllowAnonymous]
        [HttpGet]
        public RequestEasyResult SpawnDeviceinfoHistory()
        {
            RequestEasyResult rst = new();

            var protectionDevices = _protectionDeviceInfoRepository.GetAllIncluding(t => t.EquipmentInfo).ToList();
            foreach (var protectionDevice in protectionDevices)
            {
                // 记录历史数据
                var protectionDeviceHistory = new ProtectionDeviceHistory
                {
                    Name = protectionDevice.Name,
                    ProtectionDeviceInfoId = protectionDevice.Id,
                    RecodeDate = protectionDevice.CreationTime,
                    ContentJson = "", // 原始数据
                    ContentNewJson = JsonConvert.SerializeObject(protectionDevice), // 新数据
                    EventDescription = "保护设备台账建立",
                    EventRecordType = EventRecordTypeEnum.Device,
                    IsSend = false  // 默认未发送
                };
                // 插入历史记录
                _protectionDeviceHistoryRepository.Insert(protectionDeviceHistory);
            }
            rst.Flag = true;
            return rst;
        }
    }
}