ANTOOZA-BACKEND/Application/Features/Admin/Store/Order/ProcessRefund/Handler.cs

using Application.Abstractions.Data;
using Application.Abstractions.Messaging;
using Application.Abstractions.Payment;
using Domain.Entities.Common.ValueObject;
using Domain.Entities.Payments.Danal;
using Domain.Entities.Payments.Danal.ValueObject;
using Domain.Entities.Store.ValueObject;
using Domain.Entities.Wallets.ValueObject;
using Microsoft.EntityFrameworkCore;
using SharedKernel.Results;

namespace Application.Features.Admin.Store.Order.ProcessRefund;

/// <summary>
/// 환불 실행 흐름 (사용자 정책):
///   1. 사전 검증 (Digital 미사용 쿠폰 가치 합)
///   2. 다날 부분 취소 호출 — 실패 시 OrderRefund.Reject + 종료
///   3. DanalCancel 행 기록
///   4. OrderRefund.Approve
///   5. 구매자 환원: 원본 OrderPay 트랜잭션의 BalanceType 별로 비례 분배해 출처 복원
///   6. 채널 보상 비례 차감 (StoreRevenue 에서). Donation 은 건드리지 않음 (출처 보존)
///   7. GameSettlement 비례 차감
///   8. Digital 상품 CouponCode 처리:
///      - OrderRefundItem 가 있으면 → 각 행의 PostRefundAction (Restore/Expire) 적용
///      - 없으면 fallback → 모든 미사용 코드 Restore (옛 환불 호환)
///      - Used 코드는 skip (안전망)
///   9. Physical 상품: 재고 복구
///  10. Order.Status 갱신 (Cancelled/Refunded/Exchanged), refund.Complete
/// </summary>
public sealed class Handler(IAppDbContext db, IDanalPayService danal) : ICommandHandler<Command, Result>
{
    public async Task<Result> Handle(Command request, CancellationToken ct)
    {
        var refund = await db.OrderRefund
            .Include(r => r.Order)
            .ThenInclude(o => o!.Items)
            .ThenInclude(i => i.Product)
            .ThenInclude(p => p!.Game)
            .Include(r => r.Order)
            .ThenInclude(o => o!.Items)
            .ThenInclude(i => i.IssuedCouponCode)
            .Include(r => r.Items)
            .FirstOrDefaultAsync(r => r.ID == request.RefundID, ct);

        if (refund is null)
        {
            return Result.Failure(Error.NotFound("Refund.NotFound", "환불 요청을 찾을 수 없습니다."));
        }

        if (refund.Status != RefundStatus.Requested)
        {
            return Result.Failure(Error.Problem("Refund.NotPending", "처리 대기 중인 환불 요청만 실행 가능합니다."));
        }

        var order = refund.Order!;

        // 1. 사전 검증 — 미사용 쿠폰 가치 합이 환불 금액 이상
        var digitalUnusedValue = 0;
        foreach (var item in order.Items)
        {
            if (item.Product?.Type != ProductType.Digital)
            {
                continue;
            }

            var unusedCount = await db.MemberInventory.CountAsync(m => m.OrderItemID == item.ID && m.CouponCode!.Status != CouponCodeStatus.Used, ct);
            digitalUnusedValue += unusedCount * item.UnitPrice;
        }

        if (digitalUnusedValue < refund.Amount)
        {
            return Result.Failure(Error.Problem("Refund.InsufficientUnusedCoupons", $"환불 금액({refund.Amount:N0}원)에 대응하는 미사용 쿠폰 코드 가치({digitalUnusedValue:N0}원)가 부족합니다. 일부 쿠폰이 이미 사용되었습니다."));
        }

        // 2. 다날 부분 취소 — PaymentOrder + DanalConfirm 조회 후 호출
        var paymentOrder = await db.PaymentOrder
            .Where(p => p.OrderID == order.OrderNumber && p.TransactionID != null)
            .OrderByDescending(p => p.ID)
            .FirstOrDefaultAsync(ct);

        DanalCancel? danalCancel = null;

        if (paymentOrder is not null && !string.IsNullOrEmpty(paymentOrder.TransactionID))
        {
            // 다날 잔액 사전 확인은 생략 (다날 응답이 RemainedAmount 반환)
            var methodCode = ((int)paymentOrder.PaymentMethod).ToString();   // 다날 API method 파라미터 (실제 매핑은 DanalPayService 내부)
            var methodEnum = paymentOrder.PaymentMethod switch
            {
                Domain.Entities.Payments.ValueObject.PaymentMethod.Card => "card",
                Domain.Entities.Payments.ValueObject.PaymentMethod.VirtualAccount => "vbank",
                Domain.Entities.Payments.ValueObject.PaymentMethod.Mobile => "mobile",
                Domain.Entities.Payments.ValueObject.PaymentMethod.Transfer => "transfer",
                Domain.Entities.Payments.ValueObject.PaymentMethod.NaverPay => "naverpay",
                Domain.Entities.Payments.ValueObject.PaymentMethod.KakaoPay => "kakaopay",
                Domain.Entities.Payments.ValueObject.PaymentMethod.Payco => "payco",
                _ => "card"
            };

            var cancelType = refund.Amount >= paymentOrder.Amount ? "FULL" : "PARTIAL";
            var cancelResult = await danal.CancelAsync(methodEnum, paymentOrder.TransactionID, refund.Amount, cancelType, ct);

            if (!cancelResult.Success)
            {
                // 다날 실패 → 환불 요청 거부 처리. 운영자 메모에 다날 응답 기록.
                refund.Reject(request.AdminUserId, request.AdminEmail, $"[다날 부분취소 실패] code={cancelResult.Code} message={cancelResult.Message}");
                await db.SaveChangesAsync(ct);
                return Result.Failure(Error.Problem("Refund.DanalCancelFailed", $"다날 부분 취소 실패: {cancelResult.Message ?? cancelResult.Code ?? "ERROR"}"));
            }

            // 3. DanalCancel 행 기록
            danalCancel = DanalCancel.CreateRequest(
                memberID: order.MemberID,
                paymentOrderID: paymentOrder.ID,
                method: paymentOrder.PaymentMethod,
                transactionID: paymentOrder.TransactionID,
                orderID: order.OrderNumber,
                amount: refund.Amount,
                merchantID: paymentOrder.MerchantID,
                cancelType: cancelType == "FULL" ? DanalCancelType.Full : DanalCancelType.Partial,
                cancelRequester: request.AdminEmail ?? request.AdminUserId,
                cancelReason: refund.Reason
            );

            danalCancel.SetResponse(
                code: cancelResult.Code ?? "SUCCESS",
                message: cancelResult.Message ?? "OK",
                originalTransactionID: cancelResult.OriginalTransactionID,
                cancelledAmount: cancelResult.CancelledAmount,
                transDate: cancelResult.TransDate,
                transTime: cancelResult.TransTime,
                balance: int.TryParse(cancelResult.Balance, out var bal) ? bal : null,
                remainedAmount: int.TryParse(cancelResult.RemainedAmount, out var rem) ? rem : null,
                approvalDateTime: cancelResult.ApprovalDateTime
            );

            db.DanalCancel.Add(danalCancel);
        }
        // PaymentOrder 가 없으면 (포인트만 결제 / 옛 주문) 다날 호출 skip

        // 4. OrderRefund 승인
        refund.Approve(request.AdminUserId, request.AdminEmail, request.AdminMemo);

        // 5. 구매자 환원: 원본 OrderPay 의 BalanceType 별 비례 분배로 출처 복원
        var buyerWallet = await db.Wallet
            .Include(w => w.Balances)
            .Include(w => w.Transactions)
            .FirstOrDefaultAsync(w => w.MemberID == order.MemberID, ct);

        if (buyerWallet is null)
        {
            return Result.Failure(Error.NotFound("Wallet.NotFound", "구매자 지갑을 찾을 수 없습니다."));
        }

        var originalByType = buyerWallet.Transactions
            .Where(t => t.TxType == WalletTransactionType.OrderPay && t.RefID == order.OrderNumber)
            .GroupBy(t => t.BalanceType)
            .ToDictionary(g => g.Key, g => (int)g.Sum(t => t.Amount.Value));

        if (originalByType.Count == 0)
        {
            return Result.Failure(Error.Problem("Refund.NoOriginalTransactions",
                "원본 결제 트랜잭션을 찾을 수 없어 환불 출처를 복원할 수 없습니다."));
        }

        var alreadyRefundedByType = buyerWallet.Transactions
            .Where(t => t.TxType == WalletTransactionType.OrderRefund && t.RefID == order.OrderNumber)
            .GroupBy(t => t.BalanceType)
            .ToDictionary(g => g.Key, g => (int)g.Sum(t => t.Amount.Value));

        var remainingByType = originalByType.ToDictionary(
            kvp => kvp.Key,
            kvp => kvp.Value - alreadyRefundedByType.GetValueOrDefault(kvp.Key, 0));

        var totalRemaining = remainingByType.Values.Sum();

        if (totalRemaining < refund.Amount)
        {
            return Result.Failure(Error.Problem("Refund.ExceedsRemaining",
                $"환불 가능 잔여 금액을 초과합니다. 요청 {refund.Amount:N0}원 / 잔여 {totalRemaining:N0}원"));
        }

        var distribution = new Dictionary<WalletBalanceType, int>();
        var distributed = 0;

        foreach (var (type, remainingForType) in remainingByType.OrderBy(x => (int)x.Key))
        {
            if (remainingForType <= 0)
            {
                continue;
            }

            var share = (int)Math.Floor((decimal)refund.Amount * remainingForType / totalRemaining);

            if (share > 0)
            {
                distribution[type] = share;
                distributed += share;
            }
        }

        var residual = refund.Amount - distributed;

        if (residual > 0)
        {
            foreach (var (type, remainingForType) in remainingByType.OrderByDescending(x => x.Value))
            {
                var assigned = distribution.GetValueOrDefault(type, 0);
                var capacity = remainingForType - assigned;

                if (capacity <= 0)
                {
                    continue;
                }

                var add = Math.Min(capacity, residual);
                distribution[type] = assigned + add;
                residual -= add;

                if (residual == 0)
                {
                    break;
                }
            }
        }

        foreach (var (type, amount) in distribution)
        {
            if (amount > 0)
            {
                buyerWallet.CreditStoreOrderRefund(type, Money.KRW(amount), reason: "ORDER_REFUND", refID: order.OrderNumber);
            }
        }

        // 6. 채널 보상 비례 차감 (Order.TotalAmount 가 0이면 비율 계산 불가 — 방어)
        if (order.TotalAmount > 0 && order.ChannelID.HasValue && order.ChannelRewardAmount > 0)
        {
            var proRataReward = (int)Math.Floor((decimal)refund.Amount * order.ChannelRewardAmount / order.TotalAmount);

            if (proRataReward > 0)
            {
                var channel = await db.Channel.AsNoTracking()
                    .Where(c => c.ID == order.ChannelID.Value)
                    .Select(c => new { c.MemberID })
                    .FirstOrDefaultAsync(ct);

                if (channel is not null)
                {
                    var channelWallet = await db.Wallet
                        .Include(w => w.Balances)
                        .Include(w => w.Transactions)
                        .FirstOrDefaultAsync(w => w.MemberID == channel.MemberID, ct);

                    if (channelWallet is not null)
                    {
                        var storeRevenueBalance = channelWallet.GetBalance(WalletBalanceType.StoreRevenue);

                        if (storeRevenueBalance.Value >= proRataReward)
                        {
                            channelWallet.DebitStoreRevenueRefund(Money.KRW(proRataReward), reason: "ORDER_REFUND_CHANNEL", refID: order.OrderNumber);
                        }
                        // 잔액 부족 시: 채널주가 이미 출금한 상황 — 정책상 환불 일시 정지 또는 음수 허용 필요
                        // 1차 정책: 부족하면 차감 skip + AdminMemo 에 기록 (별도 정정 절차)
                        else
                        {
                            refund.Reject(request.AdminUserId, request.AdminEmail, $"채널 보상 차감 실패: 잔액 부족 (필요 {proRataReward:N0}, 잔액 {(int)storeRevenueBalance.Value:N0}). 별도 정정 정산 필요.");
                            await db.SaveChangesAsync(ct);
                            return Result.Failure(Error.Problem("Refund.ChannelInsufficient", "채널 보상 차감 실패: 잔액 부족"));
                        }
                    }
                }
            }
        }

        // 7. GameSettlement 비례 차감
        if (order.TotalAmount > 0 && order.GameRevenueAmount > 0)
        {
            // Items 의 게임별로 비례 차감
            foreach (var item in order.Items)
            {
                if (item.Product is null || item.Product.Game is null)
                {
                    continue;
                }

                var lineTotal = item.UnitPrice * item.Quantity;

                if (lineTotal <= 0)
                {
                    continue;
                }

                var lineGameRevenue = (int)Math.Floor((decimal)lineTotal * item.Product.Game.CommissionRate / 100m);
                var proRataGame = (int)Math.Floor((decimal)refund.Amount * lineGameRevenue / order.TotalAmount);

                if (proRataGame <= 0)
                {
                    continue;
                }

                var year = order.PaidAt?.Year ?? order.CreatedAt.Year;
                var month = order.PaidAt?.Month ?? order.CreatedAt.Month;

                var settlement = await db.GameSettlement
                    .FirstOrDefaultAsync(s => s.GameID == item.Product.GameID && s.Year == year && s.Month == month, ct);

                if (settlement is not null && settlement.Status == GameSettlementStatus.Pending)
                {
                    settlement.SubtractRevenue(proRataGame);
                }
            }
        }

        // 8. CouponCode 처리:
        //    - OrderRefundItem 가 있으면 명시된 CouponCode 만, 명시된 PostRefundAction 적용
        //    - 없으면 fallback (옛 환불 호환) — 미사용 코드 모두 RestoreToAvailable
        if (refund.Items.Count > 0)
        {
            var refundItemCouponIds = refund.Items.Select(x => x.CouponCodeID).ToList();

            var inventories = await db.MemberInventory
                .Include(m => m.CouponCode)
                .Where(m => refundItemCouponIds.Contains(m.CouponCodeID))
                .ToListAsync(ct);

            var invByCouponCode = inventories.ToDictionary(m => m.CouponCodeID);

            foreach (var refundItem in refund.Items)
            {
                if (!invByCouponCode.TryGetValue(refundItem.CouponCodeID, out var inv) || inv.CouponCode is null)
                {
                    continue;   // 이미 처리됐거나 데이터 없음 — skip
                }

                if (inv.CouponCode.Status == CouponCodeStatus.Used)
                {
                    continue;   // 안전망: Used 는 회수/만료 모두 불가
                }

                switch (refundItem.PostRefundAction)
                {
                    case CouponPostRefundAction.Restore:
                        inv.CouponCode.RestoreToAvailable();
                        break;
                    case CouponPostRefundAction.Expire:
                        inv.CouponCode.Expire();
                        break;
                }

                db.MemberInventory.Remove(inv);
            }
        }
        else
        {
            // Fallback: OrderRefundItem 없는 옛 환불 — 미사용 코드 모두 회수
            foreach (var item in order.Items)
            {
                if (item.Product is null)
                {
                    continue;
                }

                if (item.Product.Type == ProductType.Physical)
                {
                    item.Product.RestoreStock(item.Quantity);
                }
                else if (item.Product.Type == ProductType.Digital)
                {
                    var memberInventories = await db.MemberInventory
                        .Include(m => m.CouponCode)
                        .Where(m => m.OrderItemID == item.ID)
                        .ToListAsync(ct);

                    foreach (var inv in memberInventories)
                    {
                        if (inv.CouponCode is null)
                        {
                            continue;
                        }

                        if (inv.CouponCode.Status == CouponCodeStatus.Used)
                        {
                            continue;
                        }

                        inv.CouponCode.RestoreToAvailable();
                        db.MemberInventory.Remove(inv);
                    }
                }
            }
        }

        // 9. Physical 상품 재고 복구 (OrderRefundItem 분기에서는 Physical 처리 안 함 — 쿠폰 환불은 Digital 만)
        //    OrderRefundItem 가 있는 환불은 쿠폰 환불 전용 — Physical 상품은 fallback 분기에서 처리.

        // 10. Order.Status 갱신
        switch (refund.Type)
        {
            case RefundType.Cancel:
                if (order.Status is OrderStatus.Pending or OrderStatus.Paid)
                {
                    order.Cancel(refund.Reason);
                }
                else
                {
                    order.MarkRefunded(refund.Reason);
                }
                break;
            case RefundType.Refund:
            case RefundType.Return:
                order.MarkRefunded(refund.Reason);
                break;
            case RefundType.Exchange:
                order.MarkExchanged();
                break;
        }

        refund.Complete();
        await db.SaveChangesAsync(ct);

        return Result.Success();
    }
}