using Abp.Auditing;
using Abp.Authorization;
using Abp.Domain.Repositories;
using Abp.Domain.Uow;
using Abp.EntityFrameworkCore.Repositories;
//using Google.Protobuf.WellKnownTypes;
using Microsoft.AspNetCore.Components.Server.Circuits;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ToolLibrary.LogHelper;
using YunDa.ISAS.Application.Core;
using YunDa.ISAS.Application.Core.Configuration;
using YunDa.ISAS.Application.Core.Session;
using YunDa.ISAS.Application.Core.SwaggerHelper;
using YunDa.ISAS.DataTransferObject;
using YunDa.ISAS.DataTransferObject.CommonDto;
using YunDa.ISAS.Entities.GeneralInformation;
using YunDa.SOMS.DataTransferObject.GeneralInformation.ProtectionDeviceInfoDto;
using YunDa.SOMS.DataTransferObject.GeneralInformation.ProtectionDeviceInfoDto.SearchCondition;
using YunDa.SOMS.Entities.GeneralInformation;

namespace YunDa.ISAS.Application.GeneralInformation.SecondaryCircuitInfo
{
    /// <summary>
    /// 二次回路类
    /// </summary>
    public class SecondaryCircuitAppService : ISASAppServiceBase, ISecondaryCircuitAppService
    {
        private readonly IRepository<ProtectionDeviceInfo, Guid> _protectionDeviceInfoRepository;
        private readonly IRepository<SecondaryCircuit, Guid> _secondaryCircuitRepository;
        private readonly IRepository<SecondaryCircuitProtectionDevice, Guid> _secondaryCircuitProtectionDeviceRepository;

        private readonly IUnitOfWorkManager _unitOfWorkManager;

        public SecondaryCircuitAppService(ISessionAppService sessionAppService
            , IRepository<ProtectionDeviceInfo, Guid> protectionDeviceInfoRepository
            , IRepository<SecondaryCircuit, Guid> secondaryCircuitRepository
            , IRepository<SecondaryCircuitProtectionDevice, Guid> secondaryCircuitProtectionDeviceRepository
            , IUnitOfWorkManager unitOfWorkManager
            , IAppServiceConfiguration appServiceConfiguration) : base(sessionAppService, appServiceConfiguration)
        {
            _protectionDeviceInfoRepository = protectionDeviceInfoRepository;
            _secondaryCircuitRepository = secondaryCircuitRepository;
            _secondaryCircuitProtectionDeviceRepository = secondaryCircuitProtectionDeviceRepository;
            _unitOfWorkManager = unitOfWorkManager;
        }

        [HttpPost]
        public async Task<RequestResult<SecondaryCircuitOutput>> CreateOrUpdateAsync(EditSecondaryCircuitInput input)
        {
            RequestResult<SecondaryCircuitOutput> result = new RequestResult<SecondaryCircuitOutput>();
            try
            {
                SecondaryCircuit entity;
                if (input.Id.HasValue)
                {
                    // 更新逻辑
                    entity = await _secondaryCircuitRepository.FirstOrDefaultAsync(input.Id.Value);
                    if (entity == null)
                    {
                        result.Message = "未找到该二次回路记录";
                        result.Flag = false;
                        return result;
                    }
                    ObjectMapper.Map(input, entity);
                    entity.PicturePath = Path.Combine(base.GetAttachmentDirectory(), "images","circuit", $"{input.Name}.jpg");
                    base.Base64ToImage(input.PictureBase64, entity.PicturePath);
                    entity.LastModificationTime = DateTime.Now;
                    entity.LastModifierUserId = base.GetCurrentUser().Id;
                }
                else
                {
                    // 新建逻辑
                    entity = ObjectMapper.Map<SecondaryCircuit>(input);
                    entity.CreationTime = DateTime.Now;
                    entity.CreatorUserId = base.GetCurrentUser().Id;
                    entity.PicturePath = Path.Combine(base.GetAttachmentDirectory(), "images","circuit", $"{input.Name}.jpg");
                    base.Base64ToImage(input.PictureBase64, entity.PicturePath);
                    await _secondaryCircuitRepository.InsertAsync(entity);
                }
                result.ResultData = ObjectMapper.Map<SecondaryCircuitOutput>(entity);
                result.Flag = true;
            }
            catch (Exception ex)
            {
                result.Message = ex.Message;
                result.Flag = false;
                Log4Helper.Error(this.GetType(), "CreateOrUpdate二次回路", ex);
            }
            return result;
        }
        [HttpGet]
        public async Task<RequestEasyResult> DeleteByIdAsync(Guid id)
        {
            RequestEasyResult result = new RequestEasyResult();
            try
            {
                await _secondaryCircuitRepository.DeleteAsync(id);
                result.Flag = true;
            }
            catch (Exception ex)
            {
                result.Message = ex.Message;
                result.Flag = false;
                Log4Helper.Error(this.GetType(), "Delete二次回路", ex);
            }
            return result;
        }
        [HttpPost]
        public async Task<RequestEasyResult> DeleteByIdsAsync(List<Guid> ids)
        {
            RequestEasyResult result = new RequestEasyResult();
            try
            {
                foreach (var id in ids)
                {
                    await _secondaryCircuitRepository.DeleteAsync(id);
                }
                result.Flag = true;
            }
            catch (Exception ex)
            {
                result.Message = ex.Message;
                result.Flag = false;
                Log4Helper.Error(this.GetType(), "批量Delete二次回路", ex);
            }
            return result;
        }
        [HttpPost]
        [ShowApi]
        [AbpAllowAnonymous]
        public async Task<RequestEasyResult> DeleteSecondaryCircuitProtectionDeviceByIdsAsync([FromBody]List<Guid> ids, [FromQuery]Guid circuitId)
        {
            RequestEasyResult result = new RequestEasyResult();
            try
            {
                var secondaryCircuitProtectionDevices = _secondaryCircuitProtectionDeviceRepository.GetAll()
                       .Where(t => t.SecondaryCircuitId == circuitId).ToList();
                var deleIds = secondaryCircuitProtectionDevices.Where(t=> ids.Contains(t.ProtectionDeviceId));
                foreach (var id in deleIds)
                {
                    await _secondaryCircuitProtectionDeviceRepository.DeleteAsync(id);
                }
                result.Flag = true;
            }
            catch (Exception ex)
            {
                result.Message = ex.Message;
                result.Flag = false;
                Log4Helper.Error(this.GetType(), "批量Delete二次回路", ex);
            }
            return result;
        }
        /// <summary>
        /// 获取回路数据
        /// </summary>
        /// <param name="searchCondition"></param>
        /// <returns></returns>
        [HttpPost]
        [ShowApi]
        [DisableAuditing]
        [AbpAllowAnonymous]
        public RequestPageResult<SecondaryCircuitOutput> FindDatas(PageSearchCondition<SecondaryCircuitSearchConditionInput> searchCondition)
        {
            RequestPageResult<SecondaryCircuitOutput> result = new RequestPageResult<SecondaryCircuitOutput>();
            try
            {
                var query = _secondaryCircuitRepository.GetAll();
                if (!string.IsNullOrWhiteSpace(searchCondition.SearchCondition.Name))
                {
                    query = query.Where(x => x.Name.Contains(searchCondition.SearchCondition.Name));
                }
                if (searchCondition.SearchCondition.TransformerSubstationId.HasValue)
                {
                    query = query.Where(x => x.TransformerSubstationId == searchCondition.SearchCondition.TransformerSubstationId.Value);
                }
                if (searchCondition.SearchCondition.IsOnlyActive.HasValue)
                {
                    query = query.Where(x => x.IsActive == searchCondition.SearchCondition.IsOnlyActive.Value);
                }
                
                if (searchCondition.SearchCondition.CircuitType.HasValue&& Enum.IsDefined(typeof(CircuitTypeEnum), searchCondition.SearchCondition.CircuitType.Value))
                {
                    query = query.Where(x => x.CircuitType == searchCondition.SearchCondition.CircuitType.Value);
                }
                result.TotalCount = query.Count();
                var data = new List<SecondaryCircuit>();
                if (searchCondition.PageSize> 0)
                {
                    data = query.Skip((searchCondition.PageIndex - 1) * searchCondition.PageSize)
                                     .Take(searchCondition.PageSize)
                                     .ToList();
                }
                else
                {
                    data = query.ToList();
                }
                result.ResultData = ObjectMapper.Map<List<SecondaryCircuitOutput>>(data);
                result.Flag = true;
            }
            catch (Exception ex)
            {
                result.Message = ex.Message;
                result.Flag = false;
                Log4Helper.Error(this.GetType(), "FindDatas二次回路", ex);
            }
            return result;
        }
        
        /// <summary>
        /// 获取回路关联的保护装置列表
        /// </summary>
        /// <param name="secondaryCircuitId"></param>
        /// <returns></returns>
        [HttpGet]
        [ShowApi]
        [AbpAllowAnonymous]
        [DisableAuditing]
        public RequestResult<List<SelectModelOutput>> FindProtectionDeviceForSelect(Guid secondaryCircuitId)
        {
            var rst = new RequestResult<List<SelectModelOutput>> { Flag = false };
            try
            {
               
                var datas = _secondaryCircuitProtectionDeviceRepository.GetAllIncluding(t=>t.ProtectionDevice)
                    .Where(e => e.IsActive)
                    .Where(t => t.SecondaryCircuitId == secondaryCircuitId)
                    ;

                rst.ResultData = datas.Select(item => new SelectModelOutput
                {
                    Value = item.Id.ToString().ToLower(),
                    Key = item.Id,
                    Text = item.ProtectionDevice.Name,
                    NodeObj = new { EquipmentInfoId = item.ProtectionDevice.EquipmentInfoId }
                }).ToList();

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

            return rst;
        }
        /// <summary>
        /// 获取回路类型
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public RequestResult<List<SelectModelOutput>> GetCircuitTypes()
        {
            RequestResult<List<SelectModelOutput>> rst = new RequestResult<List<SelectModelOutput>>();
            try
            {

                var data = base.GetEnumTypes<CircuitTypeEnum>();
                rst.ResultData = data.ToList();
                rst.Flag = true;
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                rst.Flag = false;
                Log4Helper.Error(this.GetType(), "获取保护装置列表", ex);

            }
            return rst;
        }
        /// <summary>
        /// 关联保护装置到二次回路
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public  async Task<RequestEasyResult> LinkProtectionDeviceToCircuitAsync(List<Guid> deviceIds, [FromQuery]Guid circuitId)
        {
            RequestEasyResult rst = new RequestEasyResult();

            try
            {
                var circuit = _secondaryCircuitRepository.GetAll().FirstOrDefault(t => t.Id == circuitId);
                if (circuit!=null)
                {
                    var secondaryCircuitProtectionDevices =   _secondaryCircuitProtectionDeviceRepository.GetAll()
                        .Where(t => t.SecondaryCircuitId == circuitId)
                        .Select(t=>t.ProtectionDeviceId);
                    var protections = _protectionDeviceInfoRepository.GetAll()
                        .Where(t => deviceIds.Contains(t.Id))
                        .Select(t=>t.Id).ToList().Except(secondaryCircuitProtectionDevices);
                    foreach (var item in protections)
                    {
                        var entity = new SecondaryCircuitProtectionDevice
                        {
                            SecondaryCircuitId = circuitId,
                            ProtectionDeviceId = item,
                            IsActive = true,
                        };
                       await _secondaryCircuitProtectionDeviceRepository.InsertAsync(entity);
                    }
                    rst.Flag = true;
                }


            }
            catch (Exception ex)
            {

                rst.Message = ex.Message;
                rst.Flag = false;
                Log4Helper.Error(this.GetType(), "关联保护装置到二次回路", ex);
            }
            return rst;
        }

#if DEBUG
        /// <summary>
        /// 生成10个测试回路信息
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [ShowApi]
        [DisableAuditing]
        [AbpAllowAnonymous]
        public async Task GenerateSecondaryCircuitTestData()
        {
            Guid transstationId = new Guid("08d87a1b-f61d-4673-8532-680d307e5d12");
            var currentUserId = base.GetCurrentUser().Id;
            // 测试数据列表
            var testData = new List<SecondaryCircuit>();
            string base64png = GetImageBase64(Path.Combine(base.GetAttachmentDirectory(), "images","circuit", "断路器控制回路.png"));
            // 生成交流回路 20 条数据
            for (int i = 1; i <= 20; i++)
            {
                var entity = new SecondaryCircuit
                {
                    SeqNo = i,
                    Name = $"交流回路_{i}",
                    CircuitType = CircuitTypeEnum.ACCircuit,
                    PicturePath = $"/images/circuit/断路器控制回路.png",
                    PictureBase64 = base64png,
                    Code = $"ACC{i:D3}",
                    TransformerSubstationId = transstationId, // 生成一个随机的变电站ID，可根据实际情况调整
                    Description = $"交流回路描述_{i}",
                    Remark = $"交流回路备注_{i}",
                    IsActive = true,
                    CreationTime = DateTime.Now,
                    CreatorUserId = currentUserId
                };
                testData.Add(entity);
            }

            // 生成控制回路 20 条数据
            for (int i = 1; i <= 20; i++)
            {
                var entity = new SecondaryCircuit
                {
                    SeqNo = i + 20,
                    Name = $"控制回路_{i}",
                    CircuitType = CircuitTypeEnum.ControlCircuit,
                    PicturePath = $"/images/circuit/断路器控制回路.png",
                    PictureBase64 = base64png,
                    Code = $"CTRL{i:D3}",
                    TransformerSubstationId = transstationId, // 生成一个随机的变电站ID，可根据实际情况调整
                    Description = $"控制回路描述_{i}",
                    Remark = $"控制回路备注_{i}",
                    IsActive = true,
                    CreationTime = DateTime.Now,
                    CreatorUserId = currentUserId
                };
                testData.Add(entity);
            }

            // 生成光纤回路 20 条数据
            for (int i = 1; i <= 20; i++)
            {
                var entity = new SecondaryCircuit
                {
                    SeqNo = i + 40,
                    Name = $"光纤回路_{i}",
                    CircuitType = CircuitTypeEnum.OpticalFiberCircuit,
                    PicturePath = $"/images/circuit/断路器控制回路.png",
                    PictureBase64 = base64png,
                    Code = $"OFC{i:D3}",
                    TransformerSubstationId = transstationId, // 生成一个随机的变电站ID，可根据实际情况调整
                    Description = $"光纤回路描述_{i}",
                    Remark = $"光纤回路备注_{i}",
                    IsActive = true,
                    CreationTime = DateTime.Now,
                    CreatorUserId = currentUserId
                };
                testData.Add(entity);
            }

            // 插入数据到数据库
            foreach (var item in testData)
            {
                _secondaryCircuitRepository.Insert(item);
            }
            //await _secondaryCircuitRepository.InsertRangeAsync(testData);
            Console.WriteLine("二次回路测试数据生成完毕！");
        }
        [HttpGet]
        [ShowApi]
        [DisableAuditing]
        [AbpAllowAnonymous]
        public async Task GenerateRandomSecondaryCircuitProtectionDeviceAssociations(int count)
        {
            // 获取所有的二次回路和保护装置
            var secondaryCircuits = await _secondaryCircuitRepository.GetAllListAsync();
            var protectionDevices = await _protectionDeviceInfoRepository.GetAllListAsync();

            // 检查是否有足够的数据
            if (!secondaryCircuits.Any() || !protectionDevices.Any())
            {
                Console.WriteLine("二次回路或保护装置数据不足，无法生成关联！");
                return;
            }

            // 创建关联列表
            var associations = new List<SecondaryCircuitProtectionDevice>();

            // 创建指定数量的随机关联数据
            var random = new Random();
            for (int i = 0; i < count; i++)
            {
                var secondaryCircuit = secondaryCircuits[random.Next(secondaryCircuits.Count)];
                var protectionDevice = protectionDevices[random.Next(protectionDevices.Count)];

                var association = new SecondaryCircuitProtectionDevice
                {
                    SecondaryCircuitId = secondaryCircuit.Id,
                    ProtectionDeviceId = protectionDevice.Id,
                    Remark = $"自动生成的关联 {i + 1}",
                    IsActive = true
                };

                associations.Add(association);
            }

            // 将生成的关联数据保存到数据库
            foreach (var item in associations)
            {
                _secondaryCircuitProtectionDeviceRepository.Insert(item);
            }
            //await _secondaryCircuitProtectionDeviceRepository.InsertRangeAsync(associations);
            Console.WriteLine("随机关联数据生成完毕！");
        }


#endif
    }
}