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.ClayObject;
using NCC.Common.Configuration;
using NCC.Common.Core.Manager;
using NCC.Common.Enum;
using NCC.Common.Extension;
using NCC.Common.Filter;
using NCC.Common.Helper;
using NCC.Common.Model.NPOI;
using NCC.DataEncryption;
using NCC.Dependency;
using NCC.DynamicApiController;
using NCC.Extend.Entitys.Dto.Common;
using NCC.Extend.Entitys.Dto.LqKhxx;
using NCC.Extend.Entitys.Dto.LqXhHyhk;
using NCC.Extend.Entitys.Enum;
using NCC.Extend.Entitys.lq_hytk_hytk;
using NCC.Extend.Entitys.lq_hytk_mx;
using NCC.Extend.Entitys.lq_kd_kdjlb;
using NCC.Extend.Entitys.lq_kd_pxmx;
using NCC.Extend.Entitys.lq_khxx;
using NCC.Extend.Entitys.lq_mdxx;
using NCC.Extend.Entitys.lq_xh_hyhk;
using NCC.Extend.Entitys.lq_xh_pxmx;
using NCC.Extend.Interfaces.LqKhxx;
using NCC.System.Entitys.Permission;
using NCC.FriendlyException;
using NCC.JsonSerialization;
using SqlSugar;
using Yitter.IdGenerator;
using NCC.Extend.Entitys.lq_kd_deductinfo;

namespace NCC.Extend.LqKhxx
{
    /// <summary>
    /// 绿纤客户（会员）资料服务
    /// </summary>
    [ApiDescriptionSettings(Tag = "绿纤客户（会员）资料服务", Name = "LqKhxx", Order = 200)]
    [Route("api/Extend/[controller]")]
    public class LqKhxxService : ILqKhxxService, IDynamicApiController, ITransient
    {
        private readonly ISqlSugarRepository<LqKhxxEntity> _lqKhxxRepository;
        private readonly SqlSugarScope _db;
        private readonly IUserManager _userManager;
        private readonly ILogger<LqKhxxService> _logger;

        /// <summary>
        /// 初始化一个<see cref="LqKhxxService"/>类型的新实例
        /// </summary>
        public LqKhxxService(ISqlSugarRepository<LqKhxxEntity> lqKhxxRepository, IUserManager userManager, ILogger<LqKhxxService> logger)
        {
            _lqKhxxRepository = lqKhxxRepository;
            _db = _lqKhxxRepository.Context;
            _userManager = userManager;
            _logger = logger;
        }

        #region 客户资料
        /// <summary>
        /// 获取客户资料
        /// </summary>
        /// <param name="id">参数</param>
        /// <returns></returns>
        [HttpGet("{id}")]
        public async Task<dynamic> GetInfo(string id)
        {
            var entity = await _db.Queryable<LqKhxxEntity>().FirstAsync(p => p.Id == id);
            var output = entity.Adapt<LqKhxxInfoOutput>();
            if (!string.IsNullOrEmpty(entity.ExpandUser))
            {
                var expandUser = await _db.Queryable<UserEntity>().Where(u => u.Id == entity.ExpandUser).FirstAsync();
                output.expandUserName = expandUser?.RealName ?? "";
            }

            if (!string.IsNullOrEmpty(entity.MainHealthUser))
            {
                var mainHealthUser = await _db.Queryable<UserEntity>().Where(u => u.Id == entity.MainHealthUser).FirstAsync();
                output.mainHealthUserName = mainHealthUser?.RealName ?? "";
            }

            if (!string.IsNullOrEmpty(entity.SubHealthUser))
            {
                var subHealthUser = await _db.Queryable<UserEntity>().Where(u => u.Id == entity.SubHealthUser).FirstAsync();
                output.subHealthUserName = subHealthUser?.RealName ?? "";
            }
            if (!string.IsNullOrEmpty(entity.Tjr))
            {
                var tjr = await _db.Queryable<UserEntity>().Where(u => u.Id == entity.Tjr).FirstAsync();
                output.tjrName = tjr?.RealName ?? "";
            }
            return output;
        }
        #endregion

        #region 客户资料列表
        /// <summary>
        /// 获取客户资料列表
        /// </summary>
        /// <param name="input">请求参数</param>
        /// <returns></returns>
        [HttpGet("")]
        public async Task<dynamic> GetList([FromQuery] LqKhxxListQueryInput input)
        {
            var sidx = input.sidx == null ? "id" : input.sidx;
            var data = await _db.Queryable<LqKhxxEntity>()
                .WhereIF(!string.IsNullOrEmpty(input.keyWord), p => p.Khmc.Contains(input.keyWord) || p.Sjh.Contains(input.keyWord) || p.Dah.Contains(input.keyWord))
                .WhereIF(!string.IsNullOrEmpty(input.id), p => p.Id.Contains(input.id))
                .WhereIF(!string.IsNullOrEmpty(input.khmc), p => p.Khmc.Contains(input.khmc))
                .WhereIF(!string.IsNullOrEmpty(input.sjh), p => p.Sjh.Contains(input.sjh))
                .WhereIF(!string.IsNullOrEmpty(input.dah), p => p.Dah.Contains(input.dah))
                .WhereIF(!string.IsNullOrEmpty(input.xb), p => p.Xb.Equals(input.xb))
                .WhereIF(!string.IsNullOrEmpty(input.gsmd), p => p.Gsmd.Contains(input.gsmd))
                .WhereIF(!string.IsNullOrEmpty(input.khlx), p => p.Khlx.Equals(input.khlx))
                .WhereIF(!string.IsNullOrEmpty(input.khjd), p => p.Khjd.Equals(input.khjd))
                .WhereIF(!string.IsNullOrEmpty(input.khxf), p => p.Khxf.Contains(input.khxf))
                .WhereIF(!string.IsNullOrEmpty(input.xfpc), p => p.Xfpc.Equals(input.xfpc))
                .WhereIF(!string.IsNullOrEmpty(input.tjr), p => p.Tjr.Contains(input.tjr))
                .WhereIF(!string.IsNullOrEmpty(input.jdqd), p => p.Jdqd.Contains(input.jdqd))
                .WhereIF(!string.IsNullOrEmpty(input.lxdz), p => p.Lxdz.Contains(input.lxdz))
                .WhereIF(!string.IsNullOrEmpty(input.bz), p => p.Bz.Contains(input.bz))
                .Select(it => new LqKhxxListOutput
                {
                    id = it.Id,
                    khmc = it.Khmc,
                    sjh = it.Sjh,
                    dah = it.Dah,
                    xb = it.Xb,
                    gsmd = it.Gsmd,
                    gsmdName = SqlFunc.Subqueryable<LqMdxxEntity>().Where(u => u.Id == it.Gsmd).Select(u => u.Dm),
                    zcsj = it.Zcsj,
                    khlx = it.Khlx,
                    khjd = it.Khjd,
                    khxf = it.Khxf,
                    xfpc = it.Xfpc,
                    tjr = it.Tjr,
                    jdqd = it.Jdqd,
                    lxdz = it.Lxdz,
                    bz = it.Bz,
                    yanglsr = it.Yanglsr,
                    yinlsr = it.Yinlsr,
                    createTime = it.CreateTime,
                    expandUser = it.ExpandUser,
                    mainHealthUser = it.MainHealthUser,
                    subHealthUser = it.SubHealthUser,
                    expandUserName = SqlFunc.Subqueryable<UserEntity>().Where(u => u.Id == it.ExpandUser).Select(u => u.RealName),
                    mainHealthUserName = SqlFunc.Subqueryable<UserEntity>().Where(u => u.Id == it.MainHealthUser).Select(u => u.RealName),
                    subHealthUserName = SqlFunc.Subqueryable<UserEntity>().Where(u => u.Id == it.SubHealthUser).Select(u => u.RealName),
                    tjrName = SqlFunc.Subqueryable<LqKhxxEntity>().Where(u => u.Id == it.Tjr).Select(u => u.Khmc),
                })
                .MergeTable()
                .OrderBy(sidx + " " + input.sort)
                .ToPagedListAsync(input.currentPage, input.pageSize);
            return PageResult<LqKhxxListOutput>.SqlSugarPageResult(data);
        }
        #endregion

        #region 新建客户资料
        /// <summary>
        /// 新建客户资料
        /// </summary>
        /// <param name="input">参数</param>
        /// <returns></returns>
        [HttpPost("")]
        public async Task Create([FromBody] LqKhxxCrInput input)
        {
            var userInfo = await _userManager.GetUserInfo();
            //判断手机号是否存在
            var user = _db.Queryable<LqKhxxEntity>().Where(u => u.Sjh == input.sjh).Any();
            if (user)
            {
                throw NCCException.Oh("该会员已存在");
            }
            var entity = input.Adapt<LqKhxxEntity>();
            entity.Id = YitIdHelper.NextId().ToString();
            entity.Dah = "LQ" + DateTime.Now.ToString("yyyyMMddHHmmssfff");
            // 处理客户消费字段：将数组转换为逗号分隔的字符串
            if (input.khxf != null && input.khxf.Count > 0)
            {
                entity.Khxf = string.Join(",", input.khxf);
            }

            var isOk = await _db.Insertable(entity).IgnoreColumns(ignoreNullColumn: true).ExecuteCommandAsync();
            if (!(isOk > 0))
                throw NCCException.Oh(ErrorCode.COM1000);
        }
        #endregion

        #region 获取客户资料无分页列表
        /// <summary>
        /// 获取客户资料无分页列表
        /// </summary>
        /// <param name="input">请求参数</param>
        /// <returns></returns>
        [NonAction]
        public async Task<dynamic> GetNoPagingList([FromQuery] LqKhxxListQueryInput input)
        {
            var sidx = input.sidx == null ? "id" : input.sidx;
            List<string> queryZcsj = input.zcsj != null ? input.zcsj.Split(',').ToObeject<List<string>>() : null;
            DateTime? startZcsj = queryZcsj != null ? Ext.GetDateTime(queryZcsj.First()) : null;
            DateTime? endZcsj = queryZcsj != null ? Ext.GetDateTime(queryZcsj.Last()) : null;
            List<string> queryYanglsr = input.yanglsr != null ? input.yanglsr.Split(',').ToObeject<List<string>>() : null;
            DateTime? startYanglsr = queryYanglsr != null ? Ext.GetDateTime(queryYanglsr.First()) : null;
            DateTime? endYanglsr = queryYanglsr != null ? Ext.GetDateTime(queryYanglsr.Last()) : null;
            List<string> queryYinlsr = input.yinlsr != null ? input.yinlsr.Split(',').ToObeject<List<string>>() : null;
            DateTime? startYinlsr = queryYinlsr != null ? Ext.GetDateTime(queryYinlsr.First()) : null;
            DateTime? endYinlsr = queryYinlsr != null ? Ext.GetDateTime(queryYinlsr.Last()) : null;
            var data = await _db.Queryable<LqKhxxEntity>()
                .WhereIF(!string.IsNullOrEmpty(input.id), p => p.Id.Contains(input.id))
                .WhereIF(!string.IsNullOrEmpty(input.khmc), p => p.Khmc.Contains(input.khmc))
                .WhereIF(!string.IsNullOrEmpty(input.sjh), p => p.Sjh.Contains(input.sjh))
                .WhereIF(!string.IsNullOrEmpty(input.dah), p => p.Dah.Contains(input.dah))
                .WhereIF(!string.IsNullOrEmpty(input.xb), p => p.Xb.Equals(input.xb))
                .WhereIF(!string.IsNullOrEmpty(input.gsmd), p => p.Gsmd.Contains(input.gsmd))
                .WhereIF(queryZcsj != null, p => p.Zcsj >= new DateTime(startZcsj.ToDate().Year, startZcsj.ToDate().Month, startZcsj.ToDate().Day, 0, 0, 0))
                .WhereIF(queryZcsj != null, p => p.Zcsj <= new DateTime(endZcsj.ToDate().Year, endZcsj.ToDate().Month, endZcsj.ToDate().Day, 23, 59, 59))
                .WhereIF(!string.IsNullOrEmpty(input.khlx), p => p.Khlx.Equals(input.khlx))
                .WhereIF(!string.IsNullOrEmpty(input.khjd), p => p.Khjd.Equals(input.khjd))
                .WhereIF(!string.IsNullOrEmpty(input.khxf), p => p.Khxf.Equals(input.khxf))
                .WhereIF(!string.IsNullOrEmpty(input.xfpc), p => p.Xfpc.Equals(input.xfpc))
                .WhereIF(!string.IsNullOrEmpty(input.tjr), p => p.Tjr.Contains(input.tjr))
                .WhereIF(!string.IsNullOrEmpty(input.jdqd), p => p.Jdqd.Contains(input.jdqd))
                .WhereIF(!string.IsNullOrEmpty(input.lxdz), p => p.Lxdz.Contains(input.lxdz))
                .WhereIF(!string.IsNullOrEmpty(input.bz), p => p.Bz.Contains(input.bz))
                .WhereIF(queryYanglsr != null, p => p.Yanglsr >= new DateTime(startYanglsr.ToDate().Year, startYanglsr.ToDate().Month, startYanglsr.ToDate().Day, 0, 0, 0))
                .WhereIF(queryYanglsr != null, p => p.Yanglsr <= new DateTime(endYanglsr.ToDate().Year, endYanglsr.ToDate().Month, endYanglsr.ToDate().Day, 23, 59, 59))
                .WhereIF(queryYinlsr != null, p => p.Yinlsr >= new DateTime(startYinlsr.ToDate().Year, startYinlsr.ToDate().Month, startYinlsr.ToDate().Day, 0, 0, 0))
                .WhereIF(queryYinlsr != null, p => p.Yinlsr <= new DateTime(endYinlsr.ToDate().Year, endYinlsr.ToDate().Month, endYinlsr.ToDate().Day, 23, 59, 59))
                .Select(it => new LqKhxxListOutput
                {
                    id = it.Id,
                    khmc = it.Khmc,
                    sjh = it.Sjh,
                    dah = it.Dah,
                    xb = it.Xb,
                    gsmd = it.Gsmd,
                    zcsj = it.Zcsj,
                    khlx = it.Khlx,
                    khjd = it.Khjd,
                    khxf = it.Khxf,
                    xfpc = it.Xfpc,
                    tjr = it.Tjr,
                    jdqd = it.Jdqd,
                    lxdz = it.Lxdz,
                    bz = it.Bz,
                    yanglsr = it.Yanglsr,
                    yinlsr = it.Yinlsr,
                    createTime = it.CreateTime,
                })
                .MergeTable()
                .OrderBy(sidx + " " + input.sort)
                .ToListAsync();
            return data;
        }
        #endregion

        #region 获取线索池客户列表
        /// <summary>
        /// 获取线索池客户列表
        /// </summary>
        /// <param name="input">查询参数</param>
        /// <returns>线索池客户列表</returns>
        [HttpGet("leads-pool")]
        public async Task<PageResult<LqKhxxListOutput>> GetLeadsPoolList([FromQuery] LqKhxxListQueryInput input)
        {
            var sidx = input.sidx == null ? "id" : input.sidx;
            List<string> queryZcsj = input.zcsj != null ? input.zcsj.Split(',').ToObeject<List<string>>() : null;
            DateTime? startZcsj = queryZcsj != null ? Ext.GetDateTime(queryZcsj.First()) : null;
            DateTime? endZcsj = queryZcsj != null ? Ext.GetDateTime(queryZcsj.Last()) : null;
            List<string> queryYanglsr = input.yanglsr != null ? input.yanglsr.Split(',').ToObeject<List<string>>() : null;
            DateTime? startYanglsr = queryYanglsr != null ? Ext.GetDateTime(queryYanglsr.First()) : null;
            DateTime? endYanglsr = queryYanglsr != null ? Ext.GetDateTime(queryYanglsr.Last()) : null;
            List<string> queryYinlsr = input.yinlsr != null ? input.yinlsr.Split(',').ToObeject<List<string>>() : null;
            DateTime? startYinlsr = queryYinlsr != null ? Ext.GetDateTime(queryYinlsr.First()) : null;
            DateTime? endYinlsr = queryYinlsr != null ? Ext.GetDateTime(queryYinlsr.Last()) : null;

            var data = await _db.Queryable<LqKhxxEntity>()
                .Where(p => p.Khlx == "线索") // 固定查询线索池客户
                .WhereIF(!string.IsNullOrEmpty(input.id), p => p.Id.Contains(input.id))
                .WhereIF(!string.IsNullOrEmpty(input.khmc), p => p.Khmc.Contains(input.khmc))
                .WhereIF(!string.IsNullOrEmpty(input.sjh), p => p.Sjh.Contains(input.sjh))
                .WhereIF(!string.IsNullOrEmpty(input.dah), p => p.Dah.Contains(input.dah))
                .WhereIF(!string.IsNullOrEmpty(input.xb), p => p.Xb.Equals(input.xb))
                .WhereIF(!string.IsNullOrEmpty(input.gsmd), p => p.Gsmd.Contains(input.gsmd))
                .WhereIF(queryZcsj != null, p => p.Zcsj >= new DateTime(startZcsj.ToDate().Year, startZcsj.ToDate().Month, startZcsj.ToDate().Day, 0, 0, 0))
                .WhereIF(queryZcsj != null, p => p.Zcsj <= new DateTime(endZcsj.ToDate().Year, endZcsj.ToDate().Month, endZcsj.ToDate().Day, 23, 59, 59))
                .WhereIF(!string.IsNullOrEmpty(input.khlx), p => p.Khlx.Equals(input.khlx))
                .WhereIF(!string.IsNullOrEmpty(input.khjd), p => p.Khjd.Equals(input.khjd))
                .WhereIF(!string.IsNullOrEmpty(input.khxf), p => p.Khxf.Contains(input.khxf))
                .WhereIF(!string.IsNullOrEmpty(input.xfpc), p => p.Xfpc.Equals(input.xfpc))
                .WhereIF(!string.IsNullOrEmpty(input.tjr), p => p.Tjr.Contains(input.tjr))
                .WhereIF(!string.IsNullOrEmpty(input.jdqd), p => p.Jdqd.Contains(input.jdqd))
                .WhereIF(!string.IsNullOrEmpty(input.lxdz), p => p.Lxdz.Contains(input.lxdz))
                .WhereIF(!string.IsNullOrEmpty(input.bz), p => p.Bz.Contains(input.bz))
                .WhereIF(queryYanglsr != null, p => p.Yanglsr >= new DateTime(startYanglsr.ToDate().Year, startYanglsr.ToDate().Month, startYanglsr.ToDate().Day, 0, 0, 0))
                .WhereIF(queryYanglsr != null, p => p.Yanglsr <= new DateTime(endYanglsr.ToDate().Year, endYanglsr.ToDate().Month, endYanglsr.ToDate().Day, 23, 59, 59))
                .WhereIF(queryYinlsr != null, p => p.Yinlsr >= new DateTime(startYinlsr.ToDate().Year, startYinlsr.ToDate().Month, startYinlsr.ToDate().Day, 0, 0, 0))
                .WhereIF(queryYinlsr != null, p => p.Yinlsr <= new DateTime(endYinlsr.ToDate().Year, endYinlsr.ToDate().Month, endYinlsr.ToDate().Day, 23, 59, 59))
                .Select(it => new LqKhxxListOutput
                {
                    id = it.Id,
                    khmc = it.Khmc,
                    sjh = it.Sjh,
                    dah = it.Dah,
                    xb = it.Xb,
                    gsmd = it.Gsmd,
                    zcsj = it.Zcsj,
                    khlx = it.Khlx,
                    khjd = it.Khjd,
                    khxf = it.Khxf,
                    xfpc = it.Xfpc,
                    tjr = it.Tjr,
                    jdqd = it.Jdqd,
                    lxdz = it.Lxdz,
                    bz = it.Bz,
                    yanglsr = it.Yanglsr,
                    yinlsr = it.Yinlsr,
                    createTime = it.CreateTime,
                    expandUser = it.ExpandUser,
                    mainHealthUser = it.MainHealthUser,
                    subHealthUser = it.SubHealthUser,
                })
                .MergeTable()
                .OrderBy(sidx + " " + input.sort)
                .ToPagedListAsync(input.currentPage, input.pageSize);
            return PageResult<LqKhxxListOutput>.SqlSugarPageResult(data);
        }
        #endregion

        #region 获取客户订单类型（首单/升单）
        /// <summary>
        /// 获取客户订单类型（首单/升单）
        /// </summary>
        /// <param name="customerId">客户ID</param>
        /// <returns>客户订单类型信息</returns>
        [HttpGet("order-type/{customerId}")]
        public async Task<LqKhxxOrderTypeOutput> GetCustomerOrderType(string customerId)
        {
            if (string.IsNullOrEmpty(customerId))
            {
                throw NCCException.Oh("客户ID不能为空");
            }
            // 查询客户是否存在
            var customerExists = await _db.Queryable<LqKhxxEntity>().Where(c => c.Id == customerId).AnyAsync();

            if (!customerExists)
            {
                throw NCCException.Oh("客户不存在");
            }
            // 查询开单记录数量
            var orderCount = await _db.Queryable<LqKdKdjlbEntity>().Where(o => o.Kdhy == customerId && o.IsEffective == StatusEnum.有效.GetHashCode() && o.Sfyj > 0).CountAsync();
            var hasOrderRecord = orderCount > 0;
            var orderType = hasOrderRecord ? "repeat_order" : "first_order";
            return new LqKhxxOrderTypeOutput
            {
                CustomerId = customerId,
                OrderType = orderType,
                HasOrderRecord = hasOrderRecord,
                OrderCount = orderCount,
            };
        }
        #endregion

        #region 导出客户资料
        /// <summary>
        /// 导出客户资料
        /// </summary>
        /// <param name="input">请求参数</param>
        /// <returns></returns>
        [HttpGet("Actions/Export")]
        public async Task<dynamic> Export([FromQuery] LqKhxxListQueryInput input)
        {
            var userInfo = await _userManager.GetUserInfo();
            var exportData = new List<LqKhxxListOutput>();
            if (input.dataType == 0)
            {
                var data = Clay.Object(await this.GetList(input));
                exportData = data.Solidify<PageResult<LqKhxxListOutput>>().list;
            }
            else
            {
                exportData = await this.GetNoPagingList(input);
            }
            List<ParamsModel> paramList =
                "[{\"value\":\"客户编码\",\"field\":\"id\"},{\"value\":\"客户名称\",\"field\":\"khmc\"},{\"value\":\"手机号\",\"field\":\"sjh\"},{\"value\":\"档案号\",\"field\":\"dah\"},{\"value\":\"性别\",\"field\":\"xb\"},{\"value\":\"公众号状态\",\"field\":\"gzhzt\"},{\"value\":\"微信昵称\",\"field\":\"wxnc\"},{\"value\":\"小程序状态\",\"field\":\"wxxcxzt\"},{\"value\":\"最近登录时间\",\"field\":\"zjdlsj\"},{\"value\":\"客户目前归属\",\"field\":\"khmqgs\"},{\"value\":\"归属门店\",\"field\":\"gsmd\"},{\"value\":\"注册时间\",\"field\":\"zcsj\"},{\"value\":\"客户类型\",\"field\":\"khlx\"},{\"value\":\"客户阶段\",\"field\":\"khjd\"},{\"value\":\"客户消费\",\"field\":\"khxf\"},{\"value\":\"消费频次\",\"field\":\"xfpc\"},{\"value\":\"推荐人\",\"field\":\"tjr\"},{\"value\":\"负责顾问\",\"field\":\"fzgw\"},{\"value\":\"美容师\",\"field\":\"mrs\"},{\"value\":\"进店渠道\",\"field\":\"jdqd\"},{\"value\":\"联系地址\",\"field\":\"lxdz\"},{\"value\":\"备注\",\"field\":\"bz\"},{\"value\":\"阳历生日\",\"field\":\"yanglsr\"},{\"value\":\"阴历生日\",\"field\":\"yinlsr\"},{\"value\":\"年龄\",\"field\":\"ml\"},]".ToList<ParamsModel>();
            ExcelConfig excelconfig = new ExcelConfig();
            excelconfig.FileName = "客户资料.xls";
            excelconfig.HeadFont = "微软雅黑";
            excelconfig.HeadPoint = 10;
            excelconfig.IsAllSizeColumn = true;
            excelconfig.ColumnModel = new List<ExcelColumnModel>();
            List<string> selectKeyList = input.selectKey.Split(',').ToList();
            foreach (var item in selectKeyList)
            {
                var isExist = paramList.Find(p => p.field == item);
                if (isExist != null)
                {
                    excelconfig.ColumnModel.Add(new ExcelColumnModel() { Column = isExist.field, ExcelColumn = isExist.value });
                }
            }
            var addPath = FileVariable.TemporaryFilePath + excelconfig.FileName;
            ExcelExportHelper<LqKhxxListOutput>.Export(exportData, excelconfig, addPath);
            var fileName = _userManager.UserId + "|" + addPath + "|xls";
            var output = new { name = excelconfig.FileName, url = "/api/File/Download?encryption=" + DESCEncryption.Encrypt(fileName, "NCC") };
            return output;
        }
        #endregion

        #region 批量删除客户资料
        /// <summary>
        /// 批量删除客户资料
        /// </summary>
        /// <param name="ids">主键数组</param>
        /// <returns></returns>
        [HttpPost("batchRemove")]
        public async Task BatchRemove([FromBody] List<string> ids)
        {
            var entitys = await _db.Queryable<LqKhxxEntity>().In(it => it.Id, ids).ToListAsync();
            if (entitys.Count > 0)
            {
                try
                {
                    //开启事务
                    _db.BeginTran();
                    //批量删除客户资料
                    await _db.Deleteable<LqKhxxEntity>().In(d => d.Id, ids).ExecuteCommandAsync();
                    //关闭事务
                    _db.CommitTran();
                }
                catch (Exception)
                {
                    //回滚事务
                    _db.RollbackTran();
                    throw NCCException.Oh(ErrorCode.COM1002);
                }
            }
        }
        #endregion

        #region 更新客户资料
        /// <summary>
        /// 更新客户资料
        /// </summary>
        /// <param name="id">主键</param>
        /// <param name="input">参数</param>
        /// <returns></returns>
        [HttpPut("{id}")]
        public async Task Update(string id, [FromBody] LqKhxxUpInput input)
        {
            var entity = input.Adapt<LqKhxxEntity>();

            // 处理客户消费字段：将数组转换为逗号分隔的字符串
            if (input.khxf != null && input.khxf.Count > 0)
            {
                entity.Khxf = string.Join(",", input.khxf);
            }

            var isOk = await _db.Updateable(entity).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
            if (!(isOk > 0))
                throw NCCException.Oh(ErrorCode.COM1001);
        }
        #endregion

        #region 删除客户资料
        /// <summary>
        /// 删除客户资料
        /// </summary>
        /// <returns></returns>
        [HttpDelete("{id}")]
        public async Task Delete(string id)
        {
            var entity = await _db.Queryable<LqKhxxEntity>().FirstAsync(p => p.Id == id);
            _ = entity ?? throw NCCException.Oh(ErrorCode.COM1005);
            var isOk = await _db.Deleteable<LqKhxxEntity>().Where(d => d.Id == id).ExecuteCommandAsync();
            if (!(isOk > 0))
                throw NCCException.Oh(ErrorCode.COM1002);
        }
        #endregion

        #region 查询会员剩余品项
        /// <summary>
        /// 查询会员剩余品项信息
        /// </summary>
        /// <remarks>
        /// 根据会员ID查询该会员的剩余品项信息，包括已购买但未消费完的品项详情
        /// 支持按来源类型(F_SourceType)区分相同品项的不同来源，确保数据准确分组
        /// 计算逻辑：剩余数量 = 购买数量 - 消费数量 - 退卡数量
        ///
        /// 示例请求：
        /// ```json
        /// GET /api/Extend/LqKhxx/GetMemberRemainingItems?memberId=GK2025022100004
        /// ```
        ///
        /// 参数说明：
        /// - memberId: 会员ID，必填参数
        ///
        /// 返回数据结构：
        /// - MemberId: 会员ID
        /// - MemberName: 会员姓名
        /// - RemainingItems: 剩余品项列表
        ///   - ItemId: 品项ID
        ///   - ItemName: 品项名称
        ///   - ItemPrice: 品项单价
        ///   - SourceType: 来源类型（用于区分相同品项的不同来源）
        ///   - TotalPurchased: 总购买数量
        ///   - ConsumedCount: 已消费数量
        ///   - RefundedCount: 已退卡数量
        ///   - RemainingCount: 剩余数量
        ///
        /// 特殊说明：
        /// - 相同品项但不同SourceType的记录会分开显示
        /// - 耗卡和退卡统计会按品项ID和SourceType精确匹配
        /// - 确保数据按SourceType正确分组且不重叠
        /// - 退卡记录会减少剩余品项数量
        /// </remarks>
        /// <param name="memberId">会员ID</param>
        /// <returns>会员剩余品项信息</returns>
        /// <response code="200">成功返回会员剩余品项信息</response>
        /// <response code="400">参数错误，会员ID不能为空</response>
        /// <response code="500">服务器错误或会员不存在</response>
        [HttpGet("GetMemberRemainingItems")]
        public async Task<MemberRemainingItemsOutput> GetMemberRemainingItems(string memberId)
        {
            if (string.IsNullOrEmpty(memberId))
            {
                throw NCCException.Oh(ErrorCode.COM1000, "会员ID不能为空");
            }
            try
            {
                // 1. 查询会员基本信息
                var memberInfo = await _db.Queryable<LqKhxxEntity>().Where(x => x.Id == memberId).FirstAsync();
                if (memberInfo == null)
                {
                    _logger.LogWarning("会员不存在，会员ID：{MemberId}", memberId);
                    throw NCCException.Oh("会员不存在");
                }
                // 2. 分步查询，避免子查询问题
                // 先查询基础品项数据
                var baseItems = await _db.Queryable<LqKdPxmxEntity>()
                    .Where(x => x.MemberId == memberId)
                    .Where(x => x.IsEffective == StatusEnum.有效.GetHashCode())
                    .Select(x => new
                    {
                        x.Id,
                        x.Px,
                        x.Pxmc,
                        x.Pxjg,
                        x.SourceType,
                        x.ProjectNumber
                    })
                    .ToListAsync();

                // 查询消费数据
                var consumedData = await _db.Queryable<LqXhPxmxEntity>()
                    .Where(x => baseItems.Select(b => b.Id).Contains(x.BillingItemId))
                    .Where(x => x.IsEffective == StatusEnum.有效.GetHashCode())
                    .GroupBy(x => x.BillingItemId)
                    .Select(x => new
                    {
                        BillingItemId = x.BillingItemId,
                        TotalConsumed = SqlFunc.AggregateSum(x.OriginalProjectNumber)
                    })
                    .ToListAsync();

                // 查询退卡数据
                var refundedData = await _db.Queryable<LqHytkMxEntity>()
                    .Where(x => baseItems.Select(b => b.Id).Contains(x.BillingItemId))
                    .Where(x => x.IsEffective == StatusEnum.有效.GetHashCode())
                    .GroupBy(x => x.BillingItemId)
                    .Select(x => new
                    {
                        BillingItemId = x.BillingItemId,
                        TotalRefunded = SqlFunc.AggregateSum(x.ProjectNumber)
                    })
                    .ToListAsync();

                //查询储扣数据
                var deductData = await _db.Queryable<LqKdDeductinfoEntity>()
                    .Where(x => baseItems.Select(b => b.Id).Contains(x.DeductId))
                    .Where(x => x.IsEffective == StatusEnum.有效.GetHashCode())
                    .GroupBy(x => x.DeductId)
                    .Select(x => new
                    {
                        BillingItemId = x.DeductId,
                        TotalDeduct = SqlFunc.AggregateSum(x.ProjectNumber)
                    })
                    .ToListAsync();

                // 组装结果
                var remainingItems = baseItems.Select(item => new RemainingItemInfo
                {
                    BillingItemId = item.Id,
                    ItemId = item.Px,
                    ItemName = item.Pxmc,
                    ItemPrice = item.Pxjg,
                    SourceType = item.SourceType,
                    TotalPurchased = item.ProjectNumber,
                    ConsumedCount = consumedData.FirstOrDefault(c => c.BillingItemId == item.Id)?.TotalConsumed ?? 0,
                    RefundedCount = refundedData.FirstOrDefault(r => r.BillingItemId == item.Id)?.TotalRefunded ?? 0,
                    DeductCount = deductData.FirstOrDefault(d => d.BillingItemId == item.Id)?.TotalDeduct ?? 0,
                }).ToList();

                // 计算剩余数量
                foreach (var item in remainingItems)
                {
                    item.RemainingCount = item.TotalPurchased - item.ConsumedCount - item.RefundedCount - item.DeductCount;
                }
                //过滤剩余数量为0的品项,先暂时为不等于 0 ，因为现在有问题，会出现负数，后面再修改
                remainingItems = remainingItems.Where(item => item.RemainingCount != 0).ToList();
                return new MemberRemainingItemsOutput
                {
                    MemberId = memberId,
                    MemberName = memberInfo.Khmc,
                    RemainingItems = remainingItems,
                };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "查询会员剩余品项失败，会员ID：{MemberId}", memberId);
                throw NCCException.Oh(ErrorCode.COM1005, "查询会员剩余品项失败");
            }
        }
        #endregion

        #region 获取会员类型枚举内容
        /// <summary>
        /// 获取会员类型枚举内容
        /// </summary>
        /// <returns>扣款类型枚举列表</returns>
        [HttpGet("deduct-types")]
        public List<EnumOutput> GetDeductTypes()
        {
            return Enum.GetValues<MemberTypeEnum>()
                .Select(e => new EnumOutput
                {
                    Value = (int)e,
                    Name = e.ToString(),
                    Description = e.GetDescription(),
                })
                .ToList();
        }
        #endregion

        #region 导入客户信息
        /// <summary>
        /// 从"清理跨店的重复"表导入客户信息
        /// </summary>
        /// <remarks>
        /// 将"清理跨店的重复"表中的数据导入到客户表中，客户类型设置为"潜客"
        /// 
        /// 导入规则：
        /// 1. 根据客户电话去重，避免重复导入
        /// 2. 客户类型统一设置为"潜客"
        /// 3. 使用YitIdHelper生成客户ID
        /// 4. 根据门店ID设置归属门店
        /// 5. 根据拓客员工设置拓客人员
        /// 
        /// 字段映射：
        /// - 客户姓名 -> khmc (客户名称)
        /// - 客户电话 -> sjh (手机号)
        /// - F_StoreId -> gsmd (归属门店)
        /// - 拓客员工 -> F_ExpandUser (拓客人员)
        /// - 日期 -> zcsj (注册时间)
        /// </remarks>
        /// <returns>导入结果</returns>
        /// <response code="200">导入成功</response>
        /// <response code="500">服务器内部错误</response>
        [HttpPost("import-customers-from-cleanup")]
        public async Task<dynamic> ImportCustomersFromCleanup()
        {
            try
            {
                _db.BeginTran();

                // 1. 查询"清理跨店的重复"表数据，按客户电话去重
                var cleanupData = await _db.Ado.SqlQueryAsync<dynamic>(@"
                    SELECT 
                        F_Id,
                        客户姓名,
                        客户电话,
                        归属门店,
                        拓客员工,
                        日期,
                        F_StoreId,
                        F_UserId
                    FROM `清理跨店的重复`
                    WHERE 客户电话 IS NOT NULL 
                      AND 客户电话 != ''
                      AND 客户姓名 IS NOT NULL 
                      AND 客户姓名 != ''
                    GROUP BY 客户电话
                    ORDER BY 日期 DESC");

                int successCount = 0;
                int skipCount = 0;
                int errorCount = 0;
                var errorMessages = new List<string>();

                foreach (var item in cleanupData)
                {
                    try
                    {
                        // 2. 检查客户是否已存在（根据手机号）
                        string phoneNumber = (string)item.客户电话;
                        var existingCustomer = await _db.Queryable<LqKhxxEntity>()
                            .Where(x => x.Sjh == phoneNumber)
                            .FirstAsync();

                        if (existingCustomer != null)
                        {
                            skipCount++;
                            continue;
                        }

                        // 3. 生成客户ID
                        string customerId = YitIdHelper.NextId().ToString();

                        // 4. 创建客户实体
                        var customerEntity = new LqKhxxEntity
                        {
                            Id = customerId,
                            Khmc = (string)item.客户姓名,
                            Sjh = (string)item.客户电话,
                            Dah = $"GK{DateTime.Now:yyyyMMdd}{customerId.Substring(customerId.Length - 6)}", // 生成档案号
                            Xb = "未知", // 默认性别
                            Gsmd = (string)item.F_StoreId, // 使用门店ID
                            Zcsj = DateTime.TryParse((string)item.日期, out DateTime regDate) ? regDate : DateTime.Now,
                            Khlx = MemberTypeEnum.线索.GetHashCode().ToString(), // 客户类型设置为潜客
                            Jdqd = "", // 进店渠道
                            Lxdz = "", // 联系地址
                            Bz = "历史潜客导入",
                            CreateTime = DateTime.Now,
                            ExpandUser = (string)item.F_UserId, // 拓客人员
                            MainHealthUser = null,
                            SubHealthUser = null
                        };

                        // 5. 插入客户记录
                        await _db.Insertable(customerEntity).ExecuteCommandAsync();

                        successCount++;
                    }
                    catch (Exception ex)
                    {
                        errorCount++;
                        errorMessages.Add($"处理客户 {(string)item.客户姓名}({(string)item.客户电话}) 时出错: {ex.Message}");
                    }
                }

                _db.CommitTran();

                return new
                {
                    success = true,
                    message = "客户信息导入完成",
                    totalRecords = cleanupData.Count,
                    successCount = successCount,
                    skipCount = skipCount,
                    errorCount = errorCount,
                    errorMessages = errorMessages.Take(10).ToList(), // 只返回前10个错误信息
                    importTime = DateTime.Now
                };
            }
            catch (Exception ex) when (!(ex is NCCException))
            {
                _db.RollbackTran();
                throw NCCException.Oh($"导入客户信息失败: {ex.Message}");
            }
        }
        #endregion

    }
}