using Infrastructure;
using Infrastructure.Attribute;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using ZR.Model;
using ZR.Model.Business;
using ZR.Model.Business.Dto;
using ZR.Model.Dto;
using ZR.Repository;
using ZR.Service.Business.IBusinessService;

namespace ZR.Service.Business
{
    /// <summary>
    /// 干线故障Service业务层处理
    /// </summary>
    [AppService(ServiceType = typeof(IOdfCableFaultsService), ServiceLifetime = LifeTime.Transient)]
    public class OdfCableFaultsService : BaseService<OdfCableFaults>, IOdfCableFaultsService
    {
        /// <summary>
        /// 按 CableId 分页查询故障列表，联查光缆名称，按 FaultTime DESC 排序
        /// </summary>
        public PagedInfo<dynamic> GetList(OdfCableFaultsQueryDto parm)
        {
            var predicate = QueryExp(parm);

            var total = 0;
            var list = Queryable()
                .Where(predicate.ToExpression())
                .LeftJoin<OdfCables>((f, c) => f.CableId == c.Id)
                .Select((f, c) => new
                {
                    f.Id,
                    f.CableId,
                    f.FaultTime,
                    f.Personnel,
                    f.FaultReason,
                    f.Mileage,
                    f.Location,
                    f.Latitude,
                    f.Longitude,
                    f.Remark,
                    f.CreatedAt,
                    CableName = c.CableName
                })
                .MergeTable()
                .OrderByDescending(it => it.FaultTime)
                .ToPageList(parm.PageNum, parm.PageSize, ref total);

            return new PagedInfo<dynamic>
            {
                Result = list.Cast<dynamic>().ToList(),
                TotalNum = total,
                PageIndex = parm.PageNum,
                PageSize = parm.PageSize
            };
        }

        /// <summary>
        /// 查询故障详情，联查光缆名称和图片列表
        /// </summary>
        public object GetDetail(int id)
        {
            var fault = Queryable()
                .LeftJoin<OdfCables>((f, c) => f.CableId == c.Id)
                .Where((f, c) => f.Id == id)
                .Select((f, c) => new
                {
                    f.Id,
                    f.CableId,
                    f.FaultTime,
                    f.Personnel,
                    f.FaultReason,
                    f.Mileage,
                    f.Location,
                    f.Latitude,
                    f.Longitude,
                    f.Remark,
                    f.UserId,
                    f.CreatedAt,
                    CableName = c.CableName
                })
                .First();

            if (fault == null)
            {
                throw new CustomException("故障记录不存在");
            }

            // 查询关联图片列表
            var images = Context.Queryable<OdfCableFaultImages>()
                .Where(img => img.FaultId == id)
                .OrderBy(img => img.Id)
                .Select(img => new { img.Id, img.ImageUrl })
                .ToList();

            return new
            {
                fault.Id,
                fault.CableId,
                fault.FaultTime,
                fault.Personnel,
                fault.FaultReason,
                fault.Mileage,
                fault.Location,
                fault.Latitude,
                fault.Longitude,
                fault.Remark,
                fault.CableName,
                fault.CreatedAt,
                Images = images
            };
        }

        /// <summary>
        /// 新增故障（含图片上传）
        /// </summary>
        public async Task<int> AddFault(OdfCableFaultAddDto dto)
        {
            // 校验 CableId 存在
            var cable = Context.Queryable<OdfCables>()
                .Where(c => c.Id == dto.CableId)
                .First();
            if (cable == null)
            {
                throw new CustomException("光缆不存在");
            }

            // 校验至少 1 张图片
            if (dto.Images == null || dto.Images.Length == 0)
            {
                throw new CustomException("请至少上传一张图片");
            }

            // 插入故障记录
            var model = new OdfCableFaults
            {
                CableId = dto.CableId,
                FaultTime = DateTime.Parse(dto.FaultTime),
                Personnel = dto.Personnel,
                FaultReason = dto.FaultReason,
                Mileage = dto.Mileage,
                Location = dto.Location,
                Latitude = dto.Latitude,
                Longitude = dto.Longitude,
                Remark = dto.Remark,
                UserId = dto.UserId,
                CreatedAt = DateTime.Now,
                UpdatedAt = DateTime.Now
            };

            var faultEntity = Insertable(model).ExecuteReturnEntity();
            int faultId = faultEntity.Id;

            // 保存图片文件并插入图片记录
            IWebHostEnvironment webHostEnvironment = App.WebHostEnvironment;
            string webRootPath = webHostEnvironment.WebRootPath;
            string uploadDir = Path.Combine("uploads", "fault");
            string fullDir = Path.Combine(webRootPath, uploadDir);

            if (!Directory.Exists(fullDir))
            {
                Directory.CreateDirectory(fullDir);
            }

            foreach (var image in dto.Images)
            {
                string fileExt = Path.GetExtension(image.FileName);
                string fileName = $"{DateTime.Now:yyyyMMdd}_{Guid.NewGuid():N}{fileExt}";
                string filePath = Path.Combine(fullDir, fileName);

                using (var stream = new FileStream(filePath, FileMode.Create))
                {
                    await image.CopyToAsync(stream);
                }

                string imageUrl = $"/{uploadDir}/{fileName}".Replace("\\", "/");

                // 拼接完整URL，前端可直接使用
                var request = App.HttpContext?.Request;
                if (request != null)
                {
                    imageUrl = $"{request.Scheme}://{request.Host}{imageUrl}";
                }

                var imageRecord = new OdfCableFaultImages
                {
                    FaultId = faultId,
                    ImageUrl = imageUrl,
                    CreatedAt = DateTime.Now
                };

                Context.Insertable(imageRecord).ExecuteCommand();
            }

            return faultId;
        }

        /// <summary>
        /// 删除故障记录并级联删除关联图片
        /// </summary>
        public int Delete(int id)
        {
            // 先删除关联图片记录
            Context.Deleteable<OdfCableFaultImages>()
                .Where(img => img.FaultId == id)
                .ExecuteCommand();

            // 再删除故障记录
            return base.Delete(id);
        }

        /// <summary>
        /// 导出故障列表
        /// </summary>
        public PagedInfo<dynamic> ExportList(OdfCableFaultsQueryDto parm)
        {
            parm.PageNum = 1;
            parm.PageSize = 100000;
            return GetList(parm);
        }

        /// <summary>
        /// 查询表达式
        /// </summary>
        private static Expressionable<OdfCableFaults> QueryExp(OdfCableFaultsQueryDto parm)
        {
            var predicate = Expressionable.Create<OdfCableFaults>();

            predicate = predicate.AndIF(parm.CableId != null, it => it.CableId == parm.CableId);
            predicate = predicate.AndIF(parm.BeginFaultTime != null, it => it.FaultTime >= parm.BeginFaultTime);
            predicate = predicate.AndIF(parm.EndFaultTime != null, it => it.FaultTime <= parm.EndFaultTime);
            predicate = predicate.AndIF(!string.IsNullOrEmpty(parm.FaultReason), it => it.FaultReason.Contains(parm.FaultReason));

            return predicate;
        }
    }
}