using Mapster;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using NCC.Common.Core.Manager;
using NCC.Dependency;
using NCC.DynamicApiController;
using NCC.Extend.Entitys.Dto.LqZjlMdsmxsz;
using NCC.Extend.Entitys.Entity.lq_zjl_mdsmxsz;
using NCC.Extend.Interfaces.LqZjlMdsmxsz;
using NCC.System.Entitys.Permission;
using NCC.Extend.Entitys.lq_mdxx;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Yitter.IdGenerator;
using NCC.Common.Filter;
using NCC.Common.Enum;
using NCC.FriendlyException;

namespace NCC.Extend
{
    /// <summary>
    /// 事业部总经理门店生命线设置服务
    /// </summary>
    [ApiDescriptionSettings(Tag = "事业部总经理门店生命线设置服务（已废弃）", Name = "LqZjlMdsmxsz", Order = 200)]
    [Route("api/Extend/[controller]")]
    public class LqZjlMdsmxszService : ILqZjlMdsmxszService, ITransient, IDynamicApiController
    {
        private readonly ISqlSugarClient _db;
        private readonly IUserManager _userManager;
        private readonly IHttpContextAccessor _httpContextAccessor;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="db">数据库上下文</param>
        /// <param name="userManager">用户管理器</param>
        /// <param name="httpContextAccessor">HTTP上下文访问器</param>
        public LqZjlMdsmxszService(
            ISqlSugarClient db,
            IUserManager userManager,
            IHttpContextAccessor httpContextAccessor)
        {
            _db = db;
            _userManager = userManager;
            _httpContextAccessor = httpContextAccessor;
        }

        #region 根据总经理用户ID查询相关设置信息
        /// <summary>
        /// 根据总经理用户ID查询相关设置信息
        /// </summary>
        /// <remarks>
        /// 根据总经理用户ID查询其管理的所有门店的生命线设置信息
        /// 
        /// 示例请求：
        /// GET /api/Extend/LqZjlMdsmxsz/GetByZjlUserid?zjlUserid=zjl001
        /// 
        /// 业务逻辑：
        /// 1. 根据总经理用户ID查询生命线设置记录
        /// 2. 关联门店表获取门店详细信息
        /// 3. 关联用户表获取总经理姓名
        /// 4. 返回完整的设置信息列表
        /// </remarks>
        /// <param name="zjlUserid">总经理用户ID</param>
        /// <returns>总经理门店生命线设置列表</returns>
        /// <response code="200">成功返回设置列表</response>
        /// <response code="400">参数错误</response>
        /// <response code="500">服务器内部错误</response>
        [HttpGet("GetByZjlUserid")]
        public async Task<dynamic> GetByZjlUserid(string zjlUserid)
        {
            if (string.IsNullOrEmpty(zjlUserid))
            {
                return new { list = new List<LqZjlMdsmxszListOutput>() };
            }

            var result = await _db.Queryable<LqZjlMdsmxszEntity>()
                .LeftJoin<UserEntity>((smx, u) => smx.ZjlUserid == u.Id)
                .LeftJoin<LqMdxxEntity>((smx, u, md) => smx.MdId == md.Id)
                .Where((smx, u, md) => smx.ZjlUserid == zjlUserid && smx.Deletemark == 0)
                .Select((smx, u, md) => new LqZjlMdsmxszListOutput
                {
                    Id = smx.Id,
                    ZjlUserid = smx.ZjlUserid,
                    ZjlName = u.RealName,
                    MdId = smx.MdId,
                    Mdbm = md.Mdbm,
                    Dm = md.Dm,
                    Smx1 = smx.Smx1,
                    Tcbl1 = smx.Tcbl1,
                    Smx2 = smx.Smx2,
                    Tcbl2 = smx.Tcbl2,
                    Smx3 = smx.Smx3,
                    Tcbl3 = smx.Tcbl3,
                    Bz = smx.Bz,
                    Cjsj = smx.Cjsj,
                    Cjry = smx.Cjry,
                    Xgsj = smx.Xgsj,
                    Xgly = smx.Xgly
                })
                .ToListAsync();

            return new { list = result };
        }
        #endregion

        #region 批量创建事业部总经理门店生命线设置
        /// <summary>
        /// 批量创建事业部总经理门店生命线设置
        /// </summary>
        /// <remarks>
        /// 为指定总经理批量创建多个门店的生命线设置
        /// 
        /// 示例请求：
        /// ```json
        /// POST /api/Extend/LqZjlMdsmxsz/BatchCreate
        /// {
        ///   "zjlUserid": "zjl001",
        ///   "items": [
        ///     {
        ///       "mdId": "md001",
        ///       "smx1": 100000.00,
        ///       "tcbBl": 3.50,
        ///       "bz": "门店A生命线设置"
        ///     },
        ///     {
        ///       "mdId": "md002", 
        ///       "smx1": 150000.00,
        ///       "tcbBl": 4.00,
        ///       "bz": "门店B生命线设置"
        ///     }
        ///   ]
        /// }
        /// ```
        /// 
        /// 业务逻辑：
        /// 1. 验证总经理用户ID是否存在
        /// 2. 验证门店ID是否有效
        /// 3. 检查是否已存在相同的设置记录
        /// 4. 批量插入新的设置记录
        /// 5. 返回创建结果
        /// </remarks>
        /// <param name="input">批量创建输入参数</param>
        /// <returns>创建结果</returns>
        /// <response code="200">成功创建设置记录</response>
        /// <response code="400">参数验证失败</response>
        /// <response code="409">存在重复记录</response>
        /// <response code="500">服务器内部错误</response>
        [HttpPost("BatchCreate")]
        public async Task<dynamic> BatchCreate(LqZjlMdsmxszBatchCreateInput input)
        {
            // 验证总经理用户是否存在
            var userExists = await _db.Queryable<UserEntity>()
                .Where(x => x.Id == input.ZjlUserid && x.DeleteMark == null)
                .AnyAsync();

            if (!userExists)
            {
                return new { success = false, message = "总经理用户不存在" };
            }

            // 验证门店ID是否有效
            var mdIds = input.Items.Select(x => x.MdId).ToList();
            var validMdIds = await _db.Queryable<LqMdxxEntity>()
                .Where(x => mdIds.Contains(x.Id))
                .Select(x => x.Id)
                .ToListAsync();

            var invalidMdIds = mdIds.Except(validMdIds).ToList();
            if (invalidMdIds.Any())
            {
                return new { success = false, message = $"以下门店ID不存在: {string.Join(", ", invalidMdIds)}" };
            }

            // 处理每个门店设置（支持新增和修改）
            var currentTime = DateTime.Now;
            var currentUser = _userManager.User?.Id ?? "system";
            var addCount = 0;
            var updateCount = 0;

            foreach (var item in input.Items)
            {
                // 检查是否已存在
                var existing = await _db.Queryable<LqZjlMdsmxszEntity>()
                    .Where(x => x.ZjlUserid == input.ZjlUserid && x.MdId == item.MdId && x.Deletemark == 0)
                    .FirstAsync();

                if (existing != null)
                {
                    // 更新现有记录
                    existing.Smx1 = item.Smx1;
                    existing.Tcbl1 = item.Tcbl1;
                    existing.Smx2 = item.Smx2;
                    existing.Tcbl2 = item.Tcbl2;
                    existing.Smx3 = item.Smx3;
                    existing.Tcbl3 = item.Tcbl3;
                    existing.Bz = item.Bz;
                    existing.Xgsj = currentTime;
                    existing.Xgly = currentUser;

                    await _db.Updateable(existing).ExecuteCommandAsync();
                    updateCount++;
                }
                else
                {
                    // 新增记录
                    var entity = new LqZjlMdsmxszEntity
                    {
                        Id = YitIdHelper.NextId().ToString(),
                        ZjlUserid = input.ZjlUserid,
                        MdId = item.MdId,
                        Smx1 = item.Smx1,
                        Tcbl1 = item.Tcbl1,
                        Smx2 = item.Smx2,
                        Tcbl2 = item.Tcbl2,
                        Smx3 = item.Smx3,
                        Tcbl3 = item.Tcbl3,
                        Bz = item.Bz,
                        Cjsj = currentTime,
                        Cjry = currentUser,
                        Deletemark = 0
                    };

                    await _db.Insertable(entity).ExecuteCommandAsync();
                    addCount++;
                }
            }

            return new
            {
                success = true,
                message = "设置成功",
                addCount = addCount,
                updateCount = updateCount,
                totalCount = addCount + updateCount
            };
        }
        #endregion

        #region 获取总经理所在组织能管理的门店
        /// <summary>
        /// 获取总经理所在组织能管理的门店
        /// </summary>
        /// <remarks>
        /// 根据总经理的组织权限，获取其能管理的所有门店列表
        /// 
        /// 示例请求：
        /// GET /api/Extend/LqZjlTcsz/ManagedStores
        /// 
        /// 业务逻辑：
        /// 2. 根据用户组织ID获取下属组织列表
        /// 3. 根据组织权限过滤门店数据
        /// 4. 返回门店基本信息列表
        /// </remarks>
        /// <returns>总经理能管理的门店列表</returns>
        /// <response code="200">成功返回门店列表</response>
        /// <response code="401">未授权访问</response>
        /// <response code="500">服务器内部错误</response>
        [HttpGet("ManagedStores/{userid}")]
        public async Task<dynamic> GetManagedStores(string userid)
        {
            var userOrganizeId = await _db.Queryable<UserEntity>().Where(x => x.Id == userid && x.DeleteMark == null).Select(x => x.OrganizeId).FirstAsync();
            // 根据组织权限获取门店
            var stores = await _db.Queryable<LqMdxxEntity>()
                .Where(s => s.Syb == userOrganizeId || s.Jyb == userOrganizeId || s.Kjb == userOrganizeId || s.Dxmb == userOrganizeId)
                .ToListAsync();
            return new { list = stores };
        }
        #endregion

        #region 分页查询
        /// <summary>
        /// 获取所有总经理门店生命线设置数据（分页查询）
        /// </summary>
        /// <param name="input">查询输入参数</param>
        /// <returns>分页数据</returns>
        [HttpGet("GetPageList")]
        public async Task<dynamic> GetPageList([FromQuery] LqZjlMdsmxszListQueryInput input)
        {
            var sidx = input.sidx == null ? "id" : input.sidx;
            var data = await _db.Queryable<LqZjlMdsmxszEntity>()
            .WhereIF(!string.IsNullOrEmpty(input.ZjlUserid), p => p.ZjlUserid.Contains(input.ZjlUserid))
            .WhereIF(!string.IsNullOrEmpty(input.MdId), p => p.MdId.Contains(input.MdId))
              .Select(it => new LqZjlMdsmxszListOutput
              {
                  Id = it.Id,
                  ZjlUserid = it.ZjlUserid,
                  ZjlName = SqlFunc.Subqueryable<UserEntity>().Where(x => x.Id == it.ZjlUserid).Select(x => x.RealName),
                  MdId = it.MdId,
                  Mdbm = SqlFunc.Subqueryable<LqMdxxEntity>().Where(x => x.Id == it.MdId).Select(x => x.Mdbm),
                  Dm = SqlFunc.Subqueryable<LqMdxxEntity>().Where(x => x.Id == it.MdId).Select(x => x.Dm),
                  Smx1 = it.Smx1,
                  Tcbl1 = it.Tcbl1,
                  Smx2 = it.Smx2,
                  Tcbl2 = it.Tcbl2,
                  Smx3 = it.Smx3,
                  Tcbl3 = it.Tcbl3,
                  Bz = it.Bz,
                  Cjsj = it.Cjsj,
                  Cjry = it.Cjry,
                  Xgsj = it.Xgsj,
                  Xgly = it.Xgly
              }).MergeTable().OrderBy(sidx + " " + input.sort).ToPagedListAsync(input.currentPage, input.pageSize);
            return PageResult<LqZjlMdsmxszListOutput>.SqlSugarPageResult(data);
        }
        #endregion

        #region 更新总经理门店生命线设置
        /// <summary>
        /// 更新总经理门店生命线设置
        /// </summary>
        [HttpPut("{id}")]
        public async Task Update(string id, [FromBody] LqZjlMdsmxszUpInput input)
        {
            var entity = await _db.Queryable<LqZjlMdsmxszEntity>()
                .Where(x => x.Id == id && x.Deletemark == 0)
                .FirstAsync();

            if (entity == null)
            {
                throw NCCException.Oh(ErrorCode.COM1001);
            }

            // 更新字段
            entity.Smx1 = input.Smx1;
            entity.Tcbl1 = input.Tcbl1;
            entity.Smx2 = input.Smx2;
            entity.Tcbl2 = input.Tcbl2;
            entity.Smx3 = input.Smx3;
            entity.Tcbl3 = input.Tcbl3;
            entity.Bz = input.Bz;
            entity.Xgsj = DateTime.Now;
            entity.Xgly = _userManager.User?.Id ?? "admin";

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

    }
}