/***********************************************************************
 *            Project: CoreCms
 *        ProjectName: 核心内容管理系统                                
 *                Web: https://www.corecms.net                      
 *             Author: 大灰灰                                          
 *              Email: jianweie@163.com                                
 *         CreateTime: 2025/12/7
 *        Description: 收益服务实现
 ***********************************************************************/

using CoreCms.Net.Configuration;
using CoreCms.Net.IRepository;
using CoreCms.Net.IRepository.UnitOfWork;
using CoreCms.Net.IServices;
using CoreCms.Net.Model.Entities;
using CoreCms.Net.Model.ViewModels.Basics;
using CoreCms.Net.Model.ViewModels.UI;

using SqlSugar;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;

namespace CoreCms.Net.Services
{
    /// <summary>
    /// 收益服务实现
    /// </summary>
    public class SQEarningsServices : BaseServices<SQEarningsRecord>, ISQEarningsServices
    {
        private readonly ISQEarningsRecordRepository _dal;
        private readonly ISQWithdrawRecordRepository _withdrawRecordRepository;
        private readonly ICoreCmsUserRepository _userRepository;
        private readonly IUnitOfWork _unitOfWork;

        public SQEarningsServices(
            IUnitOfWork unitOfWork,
            ISQEarningsRecordRepository dal,
            ISQWithdrawRecordRepository withdrawRecordRepository,
            ICoreCmsUserRepository userRepository)
        {
            _dal = dal;
            base.BaseDal = dal;
            _unitOfWork = unitOfWork;
            _withdrawRecordRepository = withdrawRecordRepository;
            _userRepository = userRepository;
        }

        #region 前端API方法

        /// <summary>
        /// 获取收益统计信息
        /// </summary>
        public async Task<EarningsSummaryDto> GetEarningsSummaryAsync(int userId)
        {
            var user = await _unitOfWork.GetDbClient().Queryable<CoreCmsUser>()
                .Where(u => u.id == userId)
                .FirstAsync();

            if (user == null)
            {
                return new EarningsSummaryDto
                {
                    pendingAmount = 0,
                    extractedAmount = 0
                };
            }

            return new EarningsSummaryDto
            {
                pendingAmount = user.pending_earnings,
                extractedAmount = user.withdrawn_earnings
            };
        }

        /// <summary>
        /// 获取收益记录列表
        /// </summary>
        public async Task<List<EarningsRecordDto>> GetEarningsRecordListAsync(int userId, int pageIndex = 1, int pageSize = 20)
        {
            var records = await _unitOfWork.GetDbClient().Queryable<SQEarningsRecord>()
                .Where(r => r.user_id == userId)
                .OrderBy(r => r.create_time, OrderByType.Desc)
                .Skip((pageIndex - 1) * pageSize)
                .Take(pageSize)
                .ToListAsync();

            return records.Select(r => new EarningsRecordDto
            {
                id = r.id,
                date = r.create_time.ToString("yyyy/M/d"),
                roomNumber = r.room_number ?? "",
                roomName = r.room_name ?? "",
                roomFee = r.room_fee,
                earnings = r.earnings,
                reservationId = r.reservation_id,
                type = r.type,
                typeName = r.type == 1 ? "佣金" : "鸽子费"
            }).ToList();
        }

        /// <summary>
        /// 获取提现记录列表
        /// </summary>
        public async Task<List<WithdrawRecordDto>> GetWithdrawRecordListAsync(int userId, int pageIndex = 1, int pageSize = 20)
        {
            var records = await _unitOfWork.GetDbClient().Queryable<SQWithdrawRecord>()
                .Where(r => r.user_id == userId)
                .OrderBy(r => r.apply_time, OrderByType.Desc)
                .Skip((pageIndex - 1) * pageSize)
                .Take(pageSize)
                .ToListAsync();

            return records.Select(r => new WithdrawRecordDto
            {
                id = r.id,
                date = r.apply_time.ToString("yyyy/M/d"),
                amount = r.amount,
                status = GetStatusName(r.status),
                statusCode = r.status,
                remark = r.remark ?? ""
            }).ToList();
        }

        /// <summary>
        /// 获取状态名称
        /// </summary>
        private string GetStatusName(int status)
        {
            return status switch
            {
                0 => "提现中",
                1 => "已到账",
                2 => "已拒绝",
                _ => "未知"
            };
        }

        /// <summary>
        /// 申请提现
        /// </summary>
        public async Task<WebApiCallBack> ApplyWithdrawAsync(int userId, decimal amount)
        {
            var jm = new WebApiCallBack();

            try
            {
                // 验证金额
                if (amount <= 0)
                {
                    jm.status = false;
                    jm.msg = "提现金额必须大于0";
                    return jm;
                }

                // 获取用户信息
                var user = await _unitOfWork.GetDbClient().Queryable<CoreCmsUser>()
                    .Where(u => u.id == userId)
                    .FirstAsync();

                if (user == null)
                {
                    jm.status = false;
                    jm.msg = "用户不存在";
                    return jm;
                }

                // 验证余额是否充足
                if (amount > user.pending_earnings)
                {
                    jm.status = false;
                    jm.msg = "提现金额不能超过待提取收益";
                    return jm;
                }

                // 开启事务
                try
                {
                    _unitOfWork.BeginTran();

                    // 创建提现记录
                    var withdrawRecord = new SQWithdrawRecord
                    {
                        user_id = userId,
                        amount = amount,
                        status = 0, // 提现中
                        apply_time = DateTime.Now,
                        remark = null
                    };

                    var insertResult = await _unitOfWork.GetDbClient().Insertable(withdrawRecord).ExecuteReturnIdentityAsync();
                    if (insertResult <= 0)
                    {
                        _unitOfWork.RollbackTran();
                        jm.status = false;
                        jm.msg = "创建提现记录失败";
                        return jm;
                    }

                    // 扣减待提现收益
                    var updateResult = await _unitOfWork.GetDbClient().Updateable<CoreCmsUser>()
                        .SetColumns(u => u.pending_earnings == u.pending_earnings - amount)
                        .Where(u => u.id == userId && u.pending_earnings >= amount)
                        .ExecuteCommandAsync();

                    if (updateResult <= 0)
                    {
                        _unitOfWork.RollbackTran();
                        jm.status = false;
                        jm.msg = "扣减待提取收益失败，请重试";
                        return jm;
                    }

                    _unitOfWork.CommitTran();

                    jm.status = true;
                    jm.msg = "提现申请已提交";
                    jm.data = new { withdrawId = insertResult };
                }
                catch
                {
                    _unitOfWork.RollbackTran();
                    throw;
                }
            }
            catch (Exception ex)
            {
                jm.status = false;
                jm.msg = "提现申请失败：" + ex.Message;
            }

            return jm;
        }

        #endregion

        #region 后台管理方法

        /// <summary>
        /// 添加收益（后台手动添加）
        /// </summary>
        public async Task<WebApiCallBack> AddEarningsAsync(int userId, int? reservationId, int? roomId, string roomNumber, string roomName, decimal roomFee, decimal earnings, int type, string remark, int operatorId)
        {
            var jm = new WebApiCallBack();

            try
            {
                // 验证金额
                if (earnings <= 0)
                {
                    jm.status = false;
                    jm.msg = "收益金额必须大于0";
                    return jm;
                }

                // 获取用户信息
                var user = await _unitOfWork.GetDbClient().Queryable<CoreCmsUser>()
                    .Where(u => u.id == userId)
                    .FirstAsync();

                if (user == null)
                {
                    jm.status = false;
                    jm.msg = "用户不存在";
                    return jm;
                }

                // 开启事务
                try
                {
                    _unitOfWork.BeginTran();

                    // 创建收益记录
                    var earningsRecord = new SQEarningsRecord
                    {
                        user_id = userId,
                        reservation_id = reservationId,
                        room_id = roomId,
                        room_number = roomNumber,
                        room_name = roomName,
                        room_fee = roomFee,
                        earnings = earnings,
                        type = type,
                        remark = remark,
                        create_time = DateTime.Now,
                        operator_id = operatorId
                    };

                    var insertResult = await _unitOfWork.GetDbClient().Insertable(earningsRecord).ExecuteReturnIdentityAsync();
                    if (insertResult <= 0)
                    {
                        _unitOfWork.RollbackTran();
                        jm.status = false;
                        jm.msg = "创建收益记录失败";
                        return jm;
                    }

                    // 增加用户待提现收益
                    var updateResult = await _unitOfWork.GetDbClient().Updateable<CoreCmsUser>()
                        .SetColumns(u => u.pending_earnings == u.pending_earnings + earnings)
                        .Where(u => u.id == userId)
                        .ExecuteCommandAsync();

                    if (updateResult <= 0)
                    {
                        _unitOfWork.RollbackTran();
                        jm.status = false;
                        jm.msg = "更新用户收益失败";
                        return jm;
                    }

                    _unitOfWork.CommitTran();

                    jm.status = true;
                    jm.msg = "添加收益成功";
                    jm.data = new { earningsId = insertResult };
                }
                catch
                {
                    _unitOfWork.RollbackTran();
                    throw;
                }
            }
            catch (Exception ex)
            {
                jm.status = false;
                jm.msg = "添加收益失败：" + ex.Message;
            }

            return jm;
        }

        /// <summary>
        /// 处理提现申请（同意/拒绝/已打款）
        /// </summary>
        public async Task<WebApiCallBack> ProcessWithdrawAsync(int withdrawId, int status, int operatorId, string remark = null)
        {
            var jm = new WebApiCallBack();

            try
            {
                // 获取提现记录
                var withdrawRecord = await _unitOfWork.GetDbClient().Queryable<SQWithdrawRecord>()
                    .Where(r => r.id == withdrawId)
                    .FirstAsync();

                if (withdrawRecord == null)
                {
                    jm.status = false;
                    jm.msg = "提现记录不存在";
                    return jm;
                }

                if (withdrawRecord.status != 0)
                {
                    jm.status = false;
                    jm.msg = "该提现申请已处理";
                    return jm;
                }

                // 开启事务
                try
                {
                    _unitOfWork.BeginTran();

                    // 更新提现记录状态
                    var updateWithdraw = await _unitOfWork.GetDbClient().Updateable<SQWithdrawRecord>()
                        .SetColumns(r => r.status == status)
                        .SetColumns(r => r.process_time == DateTime.Now)
                        .SetColumns(r => r.operator_id == operatorId)
                        .SetColumnsIF(!string.IsNullOrEmpty(remark), r => r.remark == remark)
                        .Where(r => r.id == withdrawId)
                        .ExecuteCommandAsync();

                    if (updateWithdraw <= 0)
                    {
                        _unitOfWork.RollbackTran();
                        jm.status = false;
                        jm.msg = "更新提现记录失败";
                        return jm;
                    }

                    // 根据状态处理
                    if (status == 1) // 已到账
                    {
                        // 增加已提现收益
                        await _unitOfWork.GetDbClient().Updateable<CoreCmsUser>()
                            .SetColumns(u => u.withdrawn_earnings == u.withdrawn_earnings + withdrawRecord.amount)
                            .Where(u => u.id == withdrawRecord.user_id)
                            .ExecuteCommandAsync();
                    }
                    else if (status == 2) // 已拒绝
                    {
                        // 退还待提现收益
                        await _unitOfWork.GetDbClient().Updateable<CoreCmsUser>()
                            .SetColumns(u => u.pending_earnings == u.pending_earnings + withdrawRecord.amount)
                            .Where(u => u.id == withdrawRecord.user_id)
                            .ExecuteCommandAsync();
                    }

                    _unitOfWork.CommitTran();

                    jm.status = true;
                    jm.msg = status == 1 ? "已标记为已到账" : (status == 2 ? "已拒绝该申请" : "处理成功");
                }
                catch
                {
                    _unitOfWork.RollbackTran();
                    throw;
                }
            }
            catch (Exception ex)
            {
                jm.status = false;
                jm.msg = "处理失败：" + ex.Message;
            }

            return jm;
        }

        #endregion

        #region 实现重写增删改查操作

        /// <summary>
        /// 重写异步插入方法
        /// </summary>
        public new async Task<AdminUiCallBack> InsertAsync(SQEarningsRecord entity)
        {
            return await _dal.InsertAsync(entity);
        }

        /// <summary>
        /// 重写异步更新方法
        /// </summary>
        public new async Task<AdminUiCallBack> UpdateAsync(SQEarningsRecord entity)
        {
            return await _dal.UpdateAsync(entity);
        }

        /// <summary>
        /// 重写删除指定ID的数据
        /// </summary>
        public new async Task<AdminUiCallBack> DeleteByIdAsync(object id)
        {
            return await _dal.DeleteByIdAsync(id);
        }

        /// <summary>
        /// 重写删除指定ID集合的数据(批量删除)
        /// </summary>
        public new async Task<AdminUiCallBack> DeleteByIdsAsync(int[] ids)
        {
            return await _dal.DeleteByIdsAsync(ids);
        }

        #endregion

        #region 重写根据条件查询分页数据

        /// <summary>
        /// 重写根据条件查询分页数据
        /// </summary>
        public new async Task<IPageList<SQEarningsRecord>> QueryPageAsync(
            Expression<Func<SQEarningsRecord, bool>> predicate,
            Expression<Func<SQEarningsRecord, object>> orderByExpression, OrderByType orderByType, int pageIndex = 1,
            int pageSize = 20, bool blUseNoLock = false)
        {
            return await _dal.QueryPageAsync(predicate, orderByExpression, orderByType, pageIndex, pageSize, blUseNoLock);
        }

        #endregion
    }
}