using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using NCC.Common.Core.Manager;
using NCC.Common.Enum;
using NCC.Common.Filter;
using NCC.Common.Helper;
using NCC.Dependency;
using NCC.DynamicApiController;
using NCC.Extend.Entitys.Dto.LqXhFeedback;
using NCC.Extend.Entitys.lq_xh_feedback;
using NCC.Extend.Entitys.lq_xh_hyhk;
using NCC.Extend.Interfaces.LqXhFeedback;
using NCC.FriendlyException;
using NCC.System.Entitys.Permission;
using SqlSugar;
using Yitter.IdGenerator;

namespace NCC.Extend
{
    /// <summary>
    /// 绿纤耗卡服务日志服务
    /// </summary>
    [ApiDescriptionSettings(Tag = "绿纤耗卡服务日志", Name = "LqXhFeedback", Order = 200, Groups = new[] { "Default" })]
    [Route("api/Extend/[controller]")]
    public class LqXhFeedbackService : ILqXhFeedbackService, IDynamicApiController, ITransient
    {
        private readonly ISqlSugarClient _db;
        private readonly IUserManager _userManager;
        private readonly ILogger<LqXhFeedbackService> _logger;

        public LqXhFeedbackService(ISqlSugarClient db, IUserManager userManager, ILogger<LqXhFeedbackService> logger)
        {
            _db = db;
            _userManager = userManager;
            _logger = logger;
        }

        #region 获取耗卡反馈详情
        /// <summary>
        /// 获取耗卡反馈详情
        /// </summary>
        /// <remarks>
        /// 根据反馈记录ID获取详细信息
        /// 
        /// 示例请求：
        /// GET /api/Extend/LqXhFeedback/GetInfo/{id}
        /// 
        /// 参数说明：
        /// - id: 反馈记录ID（路径参数）
        /// </remarks>
        /// <param name="id">反馈记录ID</param>
        /// <returns>耗卡反馈详情</returns>
        /// <response code="200">成功返回耗卡反馈详情</response>
        /// <response code="404">记录不存在</response>
        /// <response code="500">服务器错误</response>
        [HttpGet("GetInfo/{id}")]
        public async Task<dynamic> GetInfo(string id)
        {
            try
            {
                var entity = await _db.Queryable<LqXhFeedbackEntity>().Where(p => p.Id == id).FirstAsync();
                if (entity == null)
                {
                    throw NCCException.Oh(ErrorCode.COM1005, "耗卡反馈记录不存在");
                }
                var output = entity.Adapt<LqXhFeedbackInfoOutput>();
                // 获取添加人姓名
                var createUser = await _db.Queryable<UserEntity>().Where(x => x.Id == entity.CreateUser).Select(x => x.RealName).FirstAsync();
                output.createUserName = createUser;
                return output;
            }
            catch (Exception ex)
            {
                throw NCCException.Oh($"获取耗卡反馈详情失败: {ex.Message}");
            }
        }
        #endregion

        #region 创建耗卡反馈
        /// <summary>
        /// 创建耗卡反馈
        /// </summary>
        /// <remarks>
        /// 创建新的耗卡反馈记录
        /// 
        /// 示例请求：
        /// ```json
        /// {
        ///   "consumeId": "耗卡记录ID",
        ///   "memberId": "会员ID",
        ///   "beforeImage": "前图片路径或Base64",
        ///   "afterImage": "后图片路径或Base64",
        ///   "remark": "反馈备注",
        ///   "kjbRemark": "科技部备注"
        /// }
        /// ```
        /// 
        /// 参数说明：
        /// - consumeId: 耗卡记录ID（必填）
        /// - memberId: 会员ID（可选）
        /// - beforeImage: 前图片（可选）
        /// - afterImage: 后图片（可选）
        /// - remark: 反馈备注（可选）
        /// - kjbRemark: 科技部备注（可选）
        /// </remarks>
        /// <param name="input">创建参数</param>
        /// <returns>创建的耗卡反馈记录</returns>
        /// <response code="200">成功创建耗卡反馈</response>
        /// <response code="400">参数错误</response>
        /// <response code="500">服务器错误</response>
        [HttpPost("Create")]
        public async Task<dynamic> Create([FromBody] LqXhFeedbackCrInput input)
        {
            try
            {
                // 验证耗卡记录是否存在
                var consumeRecord = await _db.Queryable<LqXhHyhkEntity>().Where(p => p.Id == input.ConsumeId).FirstAsync();
                if (consumeRecord == null)
                {
                    throw NCCException.Oh(ErrorCode.COM1005, "耗卡记录不存在");
                }
                var entity = input.Adapt<LqXhFeedbackEntity>();
                entity.Id = YitIdHelper.NextId().ToString();
                entity.CreateUser = _userManager.UserId;
                entity.CreateTime = DateTime.Now;
                entity.UpdateTime = DateTime.Now;
                entity.MemberId = consumeRecord.Hy;
                await _db.Insertable(entity).ExecuteCommandAsync();
                return entity.Adapt<LqXhFeedbackInfoOutput>();
            }
            catch (Exception ex)
            {
                throw NCCException.Oh($"创建耗卡反馈失败: {ex.Message}");
            }
        }
        #endregion

        #region 更新耗卡反馈
        /// <summary>
        /// 更新耗卡反馈
        /// </summary>
        /// <remarks>
        /// 更新现有的耗卡反馈记录
        /// 
        /// 示例请求：
        /// ```json
        /// {
        ///   "id": "反馈记录ID",
        ///   "consumeId": "耗卡记录ID",
        ///   "memberId": "会员ID",
        ///   "beforeImage": "前图片路径或Base64",
        ///   "afterImage": "后图片路径或Base64",
        ///   "remark": "反馈备注",
        ///   "kjbRemark": "科技部备注"
        /// }
        /// ```
        /// 
        /// 参数说明：
        /// - id: 反馈记录ID（必填）
        /// - consumeId: 耗卡记录ID（必填）
        /// - memberId: 会员ID（可选）
        /// - beforeImage: 前图片（可选）
        /// - afterImage: 后图片（可选）
        /// - remark: 反馈备注（可选）
        /// - kjbRemark: 科技部备注（可选）
        /// </remarks>
        /// <param name="input">更新参数</param>
        /// <returns>更新后的耗卡反馈记录</returns>
        /// <response code="200">成功更新耗卡反馈</response>
        /// <response code="400">参数错误</response>
        /// <response code="404">记录不存在</response>
        /// <response code="500">服务器错误</response>
        [HttpPut("Update")]
        public async Task<dynamic> Update([FromBody] LqXhFeedbackUpInput input)
        {
            try
            {
                var entity = await _db.Queryable<LqXhFeedbackEntity>().Where(p => p.Id == input.id).FirstAsync();
                if (entity == null)
                {
                    throw NCCException.Oh(ErrorCode.COM1005, "耗卡反馈记录不存在");
                }
                // 验证耗卡记录是否存在
                var consumeRecord = await _db.Queryable<LqXhHyhkEntity>().Where(p => p.Id == input.ConsumeId).FirstAsync();

                if (consumeRecord == null)
                {
                    throw NCCException.Oh(ErrorCode.COM1005, "耗卡记录不存在");
                }
                entity.ConsumeId = input.ConsumeId;
                entity.BeforeImage = input.BeforeImage;
                entity.AfterImage = input.AfterImage;
                entity.Remark = input.Remark;
                entity.KjbRemark = input.KjbRemark;
                entity.UpdateTime = DateTime.Now;
                entity.MemberId = consumeRecord.Hy;
                await _db.Updateable(entity).ExecuteCommandAsync();
                return entity.Adapt<LqXhFeedbackInfoOutput>();
            }
            catch (Exception ex)
            {
                throw NCCException.Oh($"更新耗卡反馈失败: {ex.Message}");
            }
        }
        #endregion

        #region 删除耗卡反馈
        /// <summary>
        /// 删除耗卡反馈
        /// </summary>
        /// <remarks>
        /// 根据反馈记录ID删除记录
        /// 
        /// 示例请求：
        /// DELETE /api/Extend/LqXhFeedback/Delete/{id}
        /// 
        /// 参数说明：
        /// - id: 反馈记录ID（路径参数）
        /// </remarks>
        /// <param name="id">反馈记录ID</param>
        /// <returns>删除结果</returns>
        /// <response code="200">成功删除耗卡反馈</response>
        /// <response code="404">记录不存在</response>
        /// <response code="500">服务器错误</response>
        [HttpDelete("Delete/{id}")]
        public async Task<dynamic> Delete(string id)
        {
            try
            {
                var entity = await _db.Queryable<LqXhFeedbackEntity>()
                    .Where(p => p.Id == id)
                    .FirstAsync();

                if (entity == null)
                {
                    throw NCCException.Oh(ErrorCode.COM1005, "耗卡反馈记录不存在");
                }

                await _db.Deleteable<LqXhFeedbackEntity>()
                    .Where(p => p.Id == id)
                    .ExecuteCommandAsync();

                return new { message = "删除成功" };
            }
            catch (Exception ex)
            {
                throw NCCException.Oh($"删除耗卡反馈失败: {ex.Message}");
            }
        }
        #endregion

        #region 根据耗卡记录ID获取反馈
        /// <summary>
        /// 根据耗卡记录ID获取反馈
        /// </summary>
        /// <remarks>
        /// 根据耗卡记录ID获取相关的所有反馈记录
        /// 
        /// 示例请求：
        /// GET /api/Extend/LqXhFeedback/GetByConsumeId/{consumeId}
        /// 
        /// 参数说明：
        /// - consumeId: 耗卡记录ID（路径参数）
        /// </remarks>
        /// <param name="consumeId">耗卡记录ID</param>
        /// <returns>耗卡反馈列表</returns>
        /// <response code="200">成功返回耗卡反馈列表</response>
        /// <response code="500">服务器错误</response>
        [HttpGet("GetByConsumeId/{consumeId}")]
        public async Task<dynamic> GetByConsumeId(string consumeId)
        {
            try
            {
                var data = await _db.Queryable<LqXhFeedbackEntity>()
                    .Where(p => p.ConsumeId == consumeId)
                    .OrderBy(p => p.CreateTime, OrderByType.Desc)
                    .Select(it => new LqXhFeedbackListOutput
                    {
                        id = it.Id,
                        consumeId = it.ConsumeId,
                        memberId = it.MemberId,
                        beforeImage = it.BeforeImage,
                        afterImage = it.AfterImage,
                        remark = it.Remark,
                        kjbRemark = it.KjbRemark,
                        createUser = it.CreateUser,
                        createUserName = SqlFunc.Subqueryable<UserEntity>().Where(x => x.Id == it.CreateUser).Select(x => x.RealName),
                        createTime = it.CreateTime,
                        updateTime = it.UpdateTime
                    })
                    .ToListAsync();

                return data;
            }
            catch (Exception ex)
            {
                throw NCCException.Oh($"获取耗卡反馈失败: {ex.Message}");
            }
        }
        #endregion

        #region 获取耗卡反馈列表
        /// <summary>
        /// 获取耗卡反馈列表
        /// </summary>
        /// <remarks>
        /// 获取耗卡反馈列表，支持分页和条件查询
        /// 
        /// 示例请求：
        /// POST /api/Extend/LqXhFeedback/GetList
        /// {
        ///   "currentPage": 1,
        ///   "pageSize": 10,
        ///   "memberId": "会员ID",
        ///   "startTime": "2025-01-01",
        ///   "endTime": "2025-01-31"
        /// }
        /// 
        /// 参数说明：
        /// - currentPage: 当前页码
        /// - pageSize: 每页条数
        /// - memberId: 会员ID（可选）
        /// - consumeId: 耗卡记录ID（可选）
        /// - startTime: 开始时间（可选）
        /// - endTime: 结束时间（可选）
        /// </remarks>
        /// <param name="input">查询参数</param>
        /// <returns>耗卡反馈列表</returns>
        [HttpPost("GetList")]
        public async Task<dynamic> GetList([FromBody] LqXhFeedbackListQueryInput input)
        {
            try
            {
                var query = _db.Queryable<LqXhFeedbackEntity>()
                    .WhereIF(!string.IsNullOrEmpty(input.MemberId), p => p.MemberId == input.MemberId)
                    .WhereIF(!string.IsNullOrEmpty(input.ConsumeId), p => p.ConsumeId == input.ConsumeId)
                    .WhereIF(!string.IsNullOrEmpty(input.CreateUser), p => p.CreateUser == input.CreateUser)
                    .WhereIF(input.StartTime.HasValue, p => p.CreateTime >= input.StartTime.Value)
                    .WhereIF(input.EndTime.HasValue, p => p.CreateTime <= input.EndTime.Value)
                    .OrderBy(p => p.CreateTime, OrderByType.Desc);

                var list = await query.ToPageListAsync(input.currentPage, input.pageSize);
                var totalCount = await query.CountAsync();

                var data = list.Adapt<List<LqXhFeedbackListOutput>>();

                // 填充添加人姓名
                if (data.Any())
                {
                    var userIds = data.Select(x => x.createUser).Distinct().ToList();
                    var users = await _db.Queryable<UserEntity>().Where(x => userIds.Contains(x.Id)).ToListAsync();
                    foreach (var item in data)
                    {
                        item.createUserName = users.FirstOrDefault(x => x.Id == item.createUser)?.RealName;
                    }
                }

                return new
                {
                    list = data,
                    pagination = new
                    {
                        pageIndex = input.currentPage,
                        pageSize = input.pageSize,
                        totalCount = totalCount
                    }
                };
            }
            catch (Exception ex)
            {
                throw NCCException.Oh($"获取耗卡反馈列表失败: {ex.Message}");
            }
        }
        #endregion
    }
}