using Model;
using Model.Dto.Inspection;
using Model.Entity.Inspection;
using Model.Mapper;
using ORM;
using Service.Interface;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Service.Implement
{
    /// <summary>
    /// 告警通知配置服务实现（渠道/通知规则/推送日志/值班排班/跨网发件箱）
    /// </summary>
    public class AlertNotifyService : IAlertNotifyService
    {
        private readonly IEnumerable<IAlertNotifier> _notifiers;

        public AlertNotifyService(IEnumerable<IAlertNotifier> notifiers)
        {
            _notifiers = notifiers;
        }

        #region 通知渠道
        /// <summary>
        /// 渠道列表（Secret 脱敏，只返回 HasSecret 标记）
        /// </summary>
        public async Task<Result<List<AlertNotifyChannelDto>>> GetChannelsAsync()
        {
            try
            {
                var list = await SqlSugarContext.DbContext.Queryable<AlertNotifyChannelEntity>()
                    .Where(x => x.IsDel == 0)
                    .OrderBy(x => x.CreateTime, OrderByType.Desc)
                    .ToListAsync();
                return Result<List<AlertNotifyChannelDto>>.Success(list.ToDtoList());
            }
            catch (Exception ex)
            {
                return Result<List<AlertNotifyChannelDto>>.Error("查询通知渠道失败", ex);
            }
        }

        /// <summary>
        /// 新增渠道
        /// </summary>
        public async Task<Result<bool>> AddChannelAsync(AlertNotifyChannelDto dto)
        {
            if (string.IsNullOrWhiteSpace(dto?.Name) || string.IsNullOrWhiteSpace(dto?.WebhookUrl))
            {
                return Result<bool>.Error("渠道名称与 Webhook 地址不能为空");
            }
            try
            {
                var entity = dto.ToEntity();
                entity.Id = 0; // 防止前端误传 Id，新增一律由雪花生成
                entity.CreateTime = DateTime.Now;
                await SqlSugarContext.DbContext.Insertable(entity).ExecuteCommandAsync();
                return Result<bool>.Success(true);
            }
            catch (Exception ex)
            {
                return Result<bool>.Error("新增通知渠道失败", ex);
            }
        }

        /// <summary>
        /// 修改渠道（Secret 传空表示保持原值不覆盖——出口已脱敏，前端编辑时不回传明文）
        /// </summary>
        public async Task<Result<bool>> UpdateChannelAsync(AlertNotifyChannelDto dto)
        {
            var entity = dto?.ToEntity();
            if (entity == null || entity.Id <= 0)
            {
                return Result<bool>.Error("渠道 Id 无效");
            }
            try
            {
                var updater = SqlSugarContext.DbContext.Updateable<AlertNotifyChannelEntity>()
                    .SetColumns(x => new AlertNotifyChannelEntity
                    {
                        ChannelType = entity.ChannelType,
                        Name = entity.Name,
                        WebhookUrl = entity.WebhookUrl,
                        PushMode = entity.PushMode,
                        IsEnabled = entity.IsEnabled,
                        Remark = entity.Remark
                    });
                // Secret 显式传值时才覆盖（空表示不修改）
                if (!string.IsNullOrWhiteSpace(entity.Secret))
                {
                    updater = updater.SetColumns(x => x.Secret == entity.Secret);
                }
                var rows = await updater.Where(x => x.Id == entity.Id && x.IsDel == 0).ExecuteCommandAsync();
                return Result<bool>.Success(rows > 0);
            }
            catch (Exception ex)
            {
                return Result<bool>.Error("修改通知渠道失败", ex);
            }
        }

        /// <summary>
        /// 删除渠道（软删除）
        /// </summary>
        public async Task<Result<bool>> DeleteChannelAsync(long id)
        {
            try
            {
                var rows = await SqlSugarContext.DbContext.Updateable<AlertNotifyChannelEntity>()
                    .SetColumns(x => x.IsDel == 1)
                    .Where(x => x.Id == id)
                    .ExecuteCommandAsync();
                return Result<bool>.Success(rows > 0);
            }
            catch (Exception ex)
            {
                return Result<bool>.Error("删除通知渠道失败", ex);
            }
        }

        /// <summary>
        /// 渠道测试推送（发送测试消息验证 Webhook 配置，结果写入推送日志）
        /// </summary>
        public async Task<Result<bool>> TestSendAsync(long channelId)
        {
            try
            {
                var channel = await SqlSugarContext.DbContext.Queryable<AlertNotifyChannelEntity>()
                    .Where(x => x.Id == channelId && x.IsDel == 0)
                    .FirstAsync();
                if (channel == null)
                {
                    return Result<bool>.Error("渠道不存在或已被删除");
                }

                var notifier = _notifiers.FirstOrDefault(n => n.ChannelType == channel.ChannelType);
                if (notifier == null)
                {
                    return Result<bool>.Error($"暂不支持的渠道类型: {channel.ChannelType}");
                }

                var message = new AlertNotifyMessage
                {
                    Title = "【测试】设备告警通知",
                    Content = $"这是一条来自 IOT 设备管理平台的测试消息。\n渠道: {channel.Name}\n时间: {DateTime.Now:yyyy-MM-dd HH:mm:ss}"
                };

                NotifyResult sendResult;
                if (channel.PushMode == NotifyPushModeEnum.Outbox)
                {
                    // Outbox 模式：测试消息也走发件箱，由 AlertBridge 实际推送
                    await InsertOutboxAsync(0, channel, message, new List<string>());
                    sendResult = NotifyResult.Ok();
                }
                else
                {
                    sendResult = await notifier.SendAsync(message, channel.WebhookUrl, channel.Secret);
                }

                await InsertLogAsync(0, channel, message.Title + " " + message.Content, sendResult, 0);
                return sendResult.Success
                    ? Result<bool>.Success(true)
                    : Result<bool>.Error($"测试推送失败: {sendResult.ErrorMsg}");
            }
            catch (Exception ex)
            {
                return Result<bool>.Error("测试推送失败", ex);
            }
        }
        #endregion

        #region 通知规则
        /// <summary>
        /// 规则列表
        /// </summary>
        public async Task<Result<List<AlertNotifyRuleDto>>> GetRulesAsync()
        {
            try
            {
                var list = await SqlSugarContext.DbContext.Queryable<AlertNotifyRuleEntity>()
                    .Where(x => x.IsDel == 0)
                    .OrderBy(x => x.AlertLevel, OrderByType.Desc)
                    .OrderBy(x => x.CreateTime, OrderByType.Desc)
                    .ToListAsync();
                return Result<List<AlertNotifyRuleDto>>.Success(list.ToDtoList());
            }
            catch (Exception ex)
            {
                return Result<List<AlertNotifyRuleDto>>.Error("查询通知规则失败", ex);
            }
        }

        /// <summary>
        /// 新增规则
        /// </summary>
        public async Task<Result<bool>> AddRuleAsync(AlertNotifyRuleDto dto)
        {
            if (string.IsNullOrWhiteSpace(dto?.RuleName))
            {
                return Result<bool>.Error("规则名称不能为空");
            }
            if (dto.ChannelId == null || !long.TryParse(dto.ChannelId, out var channelId) || channelId <= 0)
            {
                return Result<bool>.Error("请选择有效的通知渠道");
            }
            try
            {
                var entity = dto.ToEntity();
                entity.Id = 0;
                entity.CreateTime = DateTime.Now;
                await SqlSugarContext.DbContext.Insertable(entity).ExecuteCommandAsync();
                return Result<bool>.Success(true);
            }
            catch (Exception ex)
            {
                return Result<bool>.Error("新增通知规则失败", ex);
            }
        }

        /// <summary>
        /// 修改规则
        /// </summary>
        public async Task<Result<bool>> UpdateRuleAsync(AlertNotifyRuleDto dto)
        {
            var entity = dto?.ToEntity();
            if (entity == null || entity.Id <= 0)
            {
                return Result<bool>.Error("规则 Id 无效");
            }
            try
            {
                var rows = await SqlSugarContext.DbContext.Updateable(entity)
                    .IgnoreColumns(x => new { x.CreateTime, x.IsDel })
                    .ExecuteCommandAsync();
                return Result<bool>.Success(rows > 0);
            }
            catch (Exception ex)
            {
                return Result<bool>.Error("修改通知规则失败", ex);
            }
        }

        /// <summary>
        /// 删除规则（软删除）
        /// </summary>
        public async Task<Result<bool>> DeleteRuleAsync(long id)
        {
            try
            {
                var rows = await SqlSugarContext.DbContext.Updateable<AlertNotifyRuleEntity>()
                    .SetColumns(x => x.IsDel == 1)
                    .Where(x => x.Id == id)
                    .ExecuteCommandAsync();
                return Result<bool>.Success(rows > 0);
            }
            catch (Exception ex)
            {
                return Result<bool>.Error("删除通知规则失败", ex);
            }
        }

        /// <summary>
        /// 启用/停用规则
        /// </summary>
        public async Task<Result<bool>> SetRuleEnabledAsync(long id, bool enabled)
        {
            try
            {
                var rows = await SqlSugarContext.DbContext.Updateable<AlertNotifyRuleEntity>()
                    .SetColumns(x => x.IsEnabled == enabled)
                    .Where(x => x.Id == id)
                    .ExecuteCommandAsync();
                return Result<bool>.Success(rows > 0);
            }
            catch (Exception ex)
            {
                return Result<bool>.Error("更新规则启用状态失败", ex);
            }
        }
        #endregion

        #region 推送日志
        /// <summary>
        /// 推送日志分页（可按成功状态/渠道筛选）
        /// </summary>
        public async Task<Result<List<AlertNotifyLogDto>>> GetLogsPagedAsync(int pageIndex, int pageSize, RefAsync<int> total,
            bool? success, long channelId = 0)
        {
            try
            {
                var list = await SqlSugarContext.DbContext.Queryable<AlertNotifyLogEntity>()
                    .Where(x => x.IsDel == 0)
                    .WhereIF(success.HasValue, x => x.Success == success!.Value)
                    .WhereIF(channelId > 0, x => x.ChannelId == channelId)
                    .OrderBy(x => x.NotifyTime, OrderByType.Desc)
                    .ToPageListAsync(pageIndex, pageSize, total);
                return Result<List<AlertNotifyLogDto>>.Success(list.ToDtoList());
            }
            catch (Exception ex)
            {
                return Result<List<AlertNotifyLogDto>>.Error("查询推送日志失败", ex);
            }
        }

        /// <summary>
        /// 写入推送日志（内部公共方法，Worker 也复用）
        /// </summary>
        internal async Task InsertLogAsync(long alertId, AlertNotifyChannelEntity channel, string content, NotifyResult result, int retryCount)
        {
            try
            {
                await SqlSugarContext.DbContext.Insertable(new AlertNotifyLogEntity
                {
                    AlertId = alertId,
                    ChannelType = channel.ChannelType,
                    ChannelId = channel.Id,
                    Target = MaskUrl(channel.WebhookUrl),
                    Content = content.Length > 1000 ? content.Substring(0, 1000) : content,
                    Success = result.Success,
                    ErrorMsg = result.ErrorMsg,
                    RetryCount = retryCount,
                    NotifyTime = DateTime.Now,
                    CreateTime = DateTime.Now
                }).ExecuteCommandAsync();
            }
            catch
            {
                // 日志写入失败不影响主流程
            }
        }

        /// <summary>
        /// Webhook 地址脱敏（保留主机名与路径结构，隐藏末段令牌与查询参数）
        /// 飞书令牌在路径末段(/hook/{token})、钉钉在 access_token、企微在 key，均需遮蔽，避免日志泄露密钥
        /// </summary>
        internal static string MaskUrl(string url)
        {
            if (string.IsNullOrWhiteSpace(url)) return url;
            try
            {
                var uri = new Uri(url);
                var segments = uri.AbsolutePath.Split('/', StringSplitOptions.RemoveEmptyEntries);
                // 保留除末段外的路径，末段（如飞书 hook 令牌）用 *** 代替；查询串一律丢弃
                string maskedPath = segments.Length > 1
                    ? "/" + string.Join("/", segments.Take(segments.Length - 1)) + "/***"
                    : "/***";
                return $"{uri.Scheme}://{uri.Host}{maskedPath}";
            }
            catch
            {
                return url.Length > 60 ? url.Substring(0, 60) + "..." : url;
            }
        }
        #endregion

        #region 值班排班
        /// <summary>
        /// 值班排班列表（按日期范围，缺省查本月）
        /// </summary>
        public async Task<Result<List<DutyRosterDto>>> GetDutiesAsync(DateTime? startDate, DateTime? endDate)
        {
            try
            {
                var start = startDate ?? new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1);
                var end = endDate ?? start.AddMonths(1).AddDays(-1);
                var list = await SqlSugarContext.DbContext.Queryable<DutyRosterEntity>()
                    .Where(x => x.IsDel == 0 && x.DutyDate >= start.Date && x.DutyDate <= end.Date)
                    .OrderBy(x => x.DutyDate, OrderByType.Asc)
                    .ToListAsync();
                return Result<List<DutyRosterDto>>.Success(list.ToDtoList());
            }
            catch (Exception ex)
            {
                return Result<List<DutyRosterDto>>.Error("查询值班排班失败", ex);
            }
        }

        /// <summary>
        /// 新增排班
        /// </summary>
        public async Task<Result<bool>> AddDutyAsync(DutyRosterDto dto)
        {
            if (string.IsNullOrWhiteSpace(dto?.PersonName))
            {
                return Result<bool>.Error("值班人不能为空");
            }
            try
            {
                var entity = dto.ToEntity();
                entity.Id = 0;
                entity.CreateTime = DateTime.Now;
                await SqlSugarContext.DbContext.Insertable(entity).ExecuteCommandAsync();
                return Result<bool>.Success(true);
            }
            catch (Exception ex)
            {
                return Result<bool>.Error("新增值班排班失败", ex);
            }
        }

        /// <summary>
        /// 修改排班
        /// </summary>
        public async Task<Result<bool>> UpdateDutyAsync(DutyRosterDto dto)
        {
            var entity = dto?.ToEntity();
            if (entity == null || entity.Id <= 0)
            {
                return Result<bool>.Error("排班 Id 无效");
            }
            try
            {
                var rows = await SqlSugarContext.DbContext.Updateable(entity)
                    .IgnoreColumns(x => new { x.CreateTime, x.IsDel })
                    .ExecuteCommandAsync();
                return Result<bool>.Success(rows > 0);
            }
            catch (Exception ex)
            {
                return Result<bool>.Error("修改值班排班失败", ex);
            }
        }

        /// <summary>
        /// 删除排班（软删除）
        /// </summary>
        public async Task<Result<bool>> DeleteDutyAsync(long id)
        {
            try
            {
                var rows = await SqlSugarContext.DbContext.Updateable<DutyRosterEntity>()
                    .SetColumns(x => x.IsDel == 1)
                    .Where(x => x.Id == id)
                    .ExecuteCommandAsync();
                return Result<bool>.Success(rows > 0);
            }
            catch (Exception ex)
            {
                return Result<bool>.Error("删除值班排班失败", ex);
            }
        }

        /// <summary>
        /// 查询指定日期的值班人
        /// </summary>
        public async Task<DutyRosterEntity?> GetDutyByDateAsync(DateTime date)
        {
            return await SqlSugarContext.DbContext.Queryable<DutyRosterEntity>()
                .Where(x => x.IsDel == 0 && x.DutyDate == date.Date)
                .FirstAsync();
        }
        #endregion

        #region 跨网发件箱（AlertBridge 对接）
        /// <summary>
        /// 写入推送日志（供 AlertNotifyWorker 直连推送后复用）
        /// </summary>
        public async Task WriteLogAsync(long alertId, long channelId, string content, bool success, string? errorMsg, int retryCount)
        {
            var channel = await SqlSugarContext.DbContext.Queryable<AlertNotifyChannelEntity>()
                .Where(x => x.Id == channelId)
                .FirstAsync();
            if (channel == null) return;
            await InsertLogAsync(alertId, channel, content,
                success ? NotifyResult.Ok() : NotifyResult.Fail(errorMsg ?? "未知错误"), retryCount);
        }

        /// <summary>
        /// 写入跨网发件箱（供 AlertNotifyWorker 的 Outbox 模式复用）
        /// </summary>
        public async Task EnqueueOutboxAsync(long alertId, long channelId, AlertNotifyMessage message, List<string> atMobiles)
        {
            var channel = await SqlSugarContext.DbContext.Queryable<AlertNotifyChannelEntity>()
                .Where(x => x.Id == channelId && x.IsDel == 0)
                .FirstAsync();
            if (channel == null) return;
            await InsertOutboxAsync(alertId, channel, message, atMobiles);
        }

        /// <summary>
        /// 拉取待推送发件箱（先查后标记；单跳板机实例场景足够，多实例并发时可改用数据库锁）
        /// </summary>
        public async Task<Result<List<AlertOutboxItemDto>>> PullOutboxAsync(int batch)
        {
            try
            {
                if (batch <= 0 || batch > 100) batch = 20;
                var pending = await SqlSugarContext.DbContext.Queryable<AlertOutboxEntity>()
                    .Where(x => x.IsDel == 0 && x.Status == OutboxStatusEnum.Pending)
                    .OrderBy(x => x.CreateTime, OrderByType.Asc)
                    .Take(batch)
                    .ToListAsync();
                if (pending.Count == 0)
                {
                    return Result<List<AlertOutboxItemDto>>.Success(new List<AlertOutboxItemDto>());
                }

                // 标记已拉取（仅更新仍为 Pending 的记录，防止重复拉取）
                var ids = pending.Select(x => x.Id).ToList();
                await SqlSugarContext.DbContext.Updateable<AlertOutboxEntity>()
                    .SetColumns(x => new AlertOutboxEntity { Status = OutboxStatusEnum.Pulled, PullTime = DateTime.Now })
                    .Where(x => ids.Contains(x.Id) && x.Status == OutboxStatusEnum.Pending)
                    .ExecuteCommandAsync();

                return Result<List<AlertOutboxItemDto>>.Success(pending.ToDtoList());
            }
            catch (Exception ex)
            {
                return Result<List<AlertOutboxItemDto>>.Error("拉取发件箱失败", ex);
            }
        }

        /// <summary>
        /// 回写发件箱推送结果（失败累加重试次数；结果同步写推送日志便于页面追溯）
        /// </summary>
        public async Task<Result<bool>> ReportOutboxResultAsync(long id, OutboxResultDto dto)
        {
            try
            {
                var item = await SqlSugarContext.DbContext.Queryable<AlertOutboxEntity>()
                    .Where(x => x.Id == id && x.IsDel == 0)
                    .FirstAsync();
                if (item == null)
                {
                    return Result<bool>.Error("发件箱记录不存在");
                }

                var status = dto?.Success == true ? OutboxStatusEnum.Success : OutboxStatusEnum.Failed;
                // 表达式树不支持 ?. 空传播，先提取局部变量
                bool success = dto?.Success == true;
                string? resultMsg = dto?.ResultMsg;
                await SqlSugarContext.DbContext.Updateable<AlertOutboxEntity>()
                    .SetColumns(x => new AlertOutboxEntity
                    {
                        Status = status,
                        FinishTime = DateTime.Now,
                        ResultMsg = resultMsg,
                        RetryCount = success ? x.RetryCount : x.RetryCount + 1
                    })
                    .Where(x => x.Id == id)
                    .ExecuteCommandAsync();

                // 推送日志（渠道信息回查，失败忽略）
                var channel = await SqlSugarContext.DbContext.Queryable<AlertNotifyChannelEntity>()
                    .Where(x => x.Id == item.ChannelId)
                    .FirstAsync();
                if (channel != null)
                {
                    await InsertLogAsync(item.AlertId, channel,
                        $"[跨网中转] {(dto?.Success == true ? "推送成功" : "推送失败")}",
                        dto?.Success == true ? NotifyResult.Ok() : NotifyResult.Fail(dto?.ResultMsg ?? "未知错误"),
                        item.RetryCount);
                }
                return Result<bool>.Success(true);
            }
            catch (Exception ex)
            {
                return Result<bool>.Error("回写发件箱结果失败", ex);
            }
        }

        /// <summary>
        /// 写入发件箱（Worker 的 Outbox 模式与渠道测试推送共用；Payload 自包含全部推送要素）
        /// </summary>
        internal async Task InsertOutboxAsync(long alertId, AlertNotifyChannelEntity channel, AlertNotifyMessage message, List<string> atMobiles)
        {
            var payload = new AlertOutboxPayload
            {
                ChannelType = (int)channel.ChannelType,
                WebhookUrl = channel.WebhookUrl,
                Secret = channel.Secret,
                Title = message.Title,
                Content = message.Content,
                AtMobiles = atMobiles
            };
            await SqlSugarContext.DbContext.Insertable(new AlertOutboxEntity
            {
                AlertId = alertId,
                ChannelId = channel.Id,
                Payload = System.Text.Json.JsonSerializer.Serialize(payload),
                Status = OutboxStatusEnum.Pending,
                CreateTime = DateTime.Now
            }).ExecuteCommandAsync();
        }
        #endregion
    }
}