using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SqlSugar;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_DTO.MES;
using WIDESEA_IBasicService;
using WIDESEA_Model.Models;

namespace WIDESEA_BasicService
{
    /// <summary>
    /// MES接口日志服务实现
    /// </summary>
    public class MesLogService : ServiceBase<Dt_MesApiLog, IRepository<Dt_MesApiLog>>, IMesLogService
    {
        private readonly ISqlSugarClient _db;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="db">数据库客户端</param>
        public MesLogService(ISqlSugarClient db, IRepository<Dt_MesApiLog> repository) : base(repository)
        {
            _db = db;
        }

        /// <summary>
        /// 记录MES接口调用日志
        /// </summary>
        /// <param name="log">日志DTO</param>
        /// <returns>是否记录成功</returns>
        public async Task<bool> LogAsync(MesApiLogDto log)
        {
            try
            {
                var entity = new Dt_MesApiLog
                {
                    ApiType = log.ApiType,
                    RequestJson = log.RequestJson,
                    ResponseJson = log.ResponseJson,
                    IsSuccess = log.IsSuccess,
                    ErrorMessage = log.ErrorMessage,
                    ElapsedMs = log.ElapsedMs,
                    CreateDate = DateTime.Now,
                    Creator = log.Creator
                };

                var result = await _db.Insertable(entity).ExecuteCommandAsync();
                return result > 0;
            }
            catch (Exception ex)
            {
                // TODO: 使用项目日志框架记录错误
                Console.WriteLine($"记录MES日志失败: {ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 获取最近的MES接口调用记录
        /// </summary>
        /// <param name="apiType">接口类型</param>
        /// <param name="count">记录数量</param>
        /// <returns>日志列表</returns>
        public async Task<List<MesApiLogDto>> GetRecentLogsAsync(string apiType, int count = 50)
        {
            try
            {
                var entities = await _db.Queryable<Dt_MesApiLog>()
                    .Where(x => x.ApiType == apiType)
                    .OrderByDescending(x => x.CreateDate)
                    .Take(count)
                    .ToListAsync();

                return entities.Select(e => new MesApiLogDto
                {
                    ApiType = e.ApiType,
                    RequestJson = e.RequestJson,
                    ResponseJson = e.ResponseJson,
                    IsSuccess = e.IsSuccess,
                    ErrorMessage = e.ErrorMessage,
                    ElapsedMs = e.ElapsedMs,
                    Creator = e.Creator
                }).ToList();
            }
            catch (Exception ex)
            {
                // TODO: 使用项目日志框架记录错误
                Console.WriteLine($"获取MES日志失败: {ex.Message}");
                return new List<MesApiLogDto>();
            }
        }

        /// <summary>
        /// 分页查询MES日志
        /// </summary>
        public async Task<(List<MesLogListItemDto> items, int total)> GetPageAsync(MesLogQueryDto query, int page, int pageSize)
        {
            var dbQuery = _db.Queryable<Dt_MesApiLog>();

            // 应用筛选条件
            if (!string.IsNullOrEmpty(query.ApiType))
            {
                dbQuery = dbQuery.Where(x => x.ApiType == query.ApiType);
            }

            if (query.IsSuccess.HasValue)
            {
                dbQuery = dbQuery.Where(x => x.IsSuccess == query.IsSuccess.Value);
            }

            if (query.StartTime.HasValue)
            {
                dbQuery = dbQuery.Where(x => x.CreateDate >= query.StartTime.Value);
            }

            if (query.EndTime.HasValue)
            {
                dbQuery = dbQuery.Where(x => x.CreateDate <= query.EndTime.Value);
            }

            if (!string.IsNullOrEmpty(query.Creator))
            {
                dbQuery = dbQuery.Where(x => x.Creator != null && x.Creator.Contains(query.Creator));
            }

            if (query.MinElapsedMs.HasValue)
            {
                dbQuery = dbQuery.Where(x => x.ElapsedMs >= query.MinElapsedMs.Value);
            }

            if (query.MaxElapsedMs.HasValue)
            {
                dbQuery = dbQuery.Where(x => x.ElapsedMs <= query.MaxElapsedMs.Value);
            }

            if (!string.IsNullOrEmpty(query.ErrorKeyword))
            {
                dbQuery = dbQuery.Where(x => x.ErrorMessage != null && x.ErrorMessage.Contains(query.ErrorKeyword));
            }

            if (!string.IsNullOrEmpty(query.JsonRequestKeyword))
            {
                dbQuery = dbQuery.Where(x => x.RequestJson != null && x.RequestJson.Contains(query.JsonRequestKeyword));
            }

            if (!string.IsNullOrEmpty(query.JsonResponseKeyword))
            {
                dbQuery = dbQuery.Where(x => x.ResponseJson != null && x.ResponseJson.Contains(query.JsonResponseKeyword));
            }

            // 获取总数
            var total = await dbQuery.CountAsync();

            // 分页查询
            var entities = await dbQuery
                .OrderByDescending(x => x.CreateDate)
                .ToPageListAsync(page, pageSize);

            var items = entities.Select(e => new MesLogListItemDto
            {
                Id = e.Id,
                ApiType = e.ApiType,
                IsSuccess = e.IsSuccess,
                RequestJson = e.RequestJson?.Length > 200 ? e.RequestJson.Substring(0, 200) + "..." : e.RequestJson,
                ResponseJson = e.ResponseJson?.Length > 200 ? e.ResponseJson.Substring(0, 200) + "..." : e.ResponseJson,
                ErrorMessage = e.ErrorMessage,
                ElapsedMs = e.ElapsedMs,
                CreateDate = e.CreateDate,
                Creator = e.Creator
            }).ToList();

            return (items, total);
        }

        /// <summary>
        /// 获取单条日志详情
        /// </summary>
        public async Task<MesLogDetailDto?> GetDetailAsync(long id)
        {
            var entity = await _db.Queryable<Dt_MesApiLog>()
                .Where(x => x.Id == id)
                .FirstAsync();

            if (entity == null)
            {
                return null;
            }

            return new MesLogDetailDto
            {
                Id = entity.Id,
                ApiType = entity.ApiType,
                IsSuccess = entity.IsSuccess,
                RequestJson = entity.RequestJson,
                ResponseJson = entity.ResponseJson,
                RequestJsonPreview = entity.RequestJson?.Length > 200 ? entity.RequestJson.Substring(0, 200) + "..." : entity.RequestJson,
                ResponseJsonPreview = entity.ResponseJson?.Length > 200 ? entity.ResponseJson.Substring(0, 200) + "..." : entity.ResponseJson,
                ErrorMessage = entity.ErrorMessage,
                ElapsedMs = entity.ElapsedMs,
                CreateDate = entity.CreateDate,
                Creator = entity.Creator,
                ModifyDate = entity.ModifyDate,
                Modifier = entity.Modifier
            };
        }

        /// <summary>
        /// 获取统计数据
        /// </summary>
        public async Task<MesLogStatisticsDto> GetStatisticsAsync(MesLogQueryDto query)
        {
            var dbQuery = _db.Queryable<Dt_MesApiLog>();

            // 应用筛选条件
            if (!string.IsNullOrEmpty(query.ApiType))
            {
                dbQuery = dbQuery.Where(x => x.ApiType == query.ApiType);
            }

            if (query.IsSuccess.HasValue)
            {
                dbQuery = dbQuery.Where(x => x.IsSuccess == query.IsSuccess.Value);
            }

            if (query.StartTime.HasValue)
            {
                dbQuery = dbQuery.Where(x => x.CreateDate >= query.StartTime.Value);
            }

            if (query.EndTime.HasValue)
            {
                dbQuery = dbQuery.Where(x => x.CreateDate <= query.EndTime.Value);
            }

            // 使用数据库聚合计算统计数据
            var totalCount = await dbQuery.CountAsync();
            var successCount = await dbQuery.Where(x => x.IsSuccess).CountAsync();
            var failedCount = totalCount - successCount;
            var successRate = totalCount > 0 ? (successCount * 100.0 / totalCount) : 0;

            // 获取所有数据来计算平均值和最大值（SqlSugar 限制）
            var allData = await dbQuery.Select(x => x.ElapsedMs).ToListAsync();
            var avgElapsed = allData.Count > 0 ? allData.Average() : 0;
            var maxElapsed = allData.Count > 0 ? allData.Max() : 0;

            // 今日数据
            var today = DateTime.Today;
            var todayCount = await dbQuery.Where(x => x.CreateDate >= today).CountAsync();

            return new MesLogStatisticsDto
            {
                TotalCount = totalCount,
                SuccessCount = successCount,
                FailedCount = failedCount,
                SuccessRate = Math.Round(successRate, 2),
                AvgElapsedMs = avgElapsed,
                MaxElapsedMs = maxElapsed,
                TodayCount = todayCount
            };
        }

        /// <summary>
        /// 导出日志数据
        /// </summary>
        public async Task<byte[]> ExportAsync(MesLogQueryDto query)
        {
            // 获取所有符合条件的数据（限制50000行）
            var (items, _) = await GetPageAsync(query, 1, 50000);

            using var memoryStream = new MemoryStream();
            using var writer = new StreamWriter(memoryStream, Encoding.UTF8);

            // 写入 UTF-8 BOM，使 Excel 能正确识别中文
            writer.Write('\uFEFF');

            // CSV 头部
            writer.WriteLine("ID,接口类型,状态,耗时(ms),错误信息,创建时间,创建人");

            // CSV 数据行
            foreach (var item in items)
            {
                var error = item.ErrorMessage?.Replace("\"", "\"\"") ?? "";
                var status = item.IsSuccess ? "成功" : "失败";
                writer.WriteLine($"{item.Id},{item.ApiType},{status},{item.ElapsedMs},\"{error}\",{item.CreateDate:yyyy-MM-dd HH:mm:ss},{item.Creator ?? ""}");
            }

            writer.Flush();
            return memoryStream.ToArray();
        }
    }
}